restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfDataServiceImplTest.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.services.impl;
   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.assertTrue;
  15 import static org.mockito.ArgumentMatchers.any;
  16 import static org.mockito.Mockito.doCallRealMethod;
  17 import static org.mockito.Mockito.doNothing;
  18 import static org.mockito.Mockito.doReturn;
  19 import static org.opendaylight.restconf.common.patch.PatchEditOperation.CREATE;
  20 import static org.opendaylight.restconf.common.patch.PatchEditOperation.DELETE;
  21 import static org.opendaylight.restconf.common.patch.PatchEditOperation.REMOVE;
  22 import static org.opendaylight.restconf.common.patch.PatchEditOperation.REPLACE;
  23 import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFalseFluentFuture;
  24 import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFluentFuture;
  25 import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateTrueFluentFuture;
  26
  27 import java.util.ArrayList;
  28 import java.util.Collection;
  29 import java.util.Collections;
  30 import java.util.HashSet;
  31 import java.util.List;
  32 import java.util.Optional;
  33 import javax.ws.rs.core.MultivaluedHashMap;
  34 import javax.ws.rs.core.MultivaluedMap;
  35 import javax.ws.rs.core.Response;
  36 import javax.ws.rs.core.UriBuilder;
  37 import javax.ws.rs.core.UriInfo;
  38 import org.junit.Before;
  39 import org.junit.Test;
  40 import org.mockito.Mock;
  41 import org.mockito.Mockito;
  42 import org.mockito.MockitoAnnotations;
  43 import org.opendaylight.mdsal.common.api.CommitInfo;
  44 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  45 import org.opendaylight.mdsal.dom.api.DOMDataBroker;
  46 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
  47 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
  48 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
  49 import org.opendaylight.mdsal.dom.api.DOMMountPoint;
  50 import org.opendaylight.mdsal.dom.api.DOMMountPointService;
  51 import org.opendaylight.mdsal.dom.api.DOMSchemaService;
  52 import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
  53 import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
  54 import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
  55 import org.opendaylight.restconf.common.context.NormalizedNodeContext;
  56 import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
  57 import org.opendaylight.restconf.common.patch.PatchContext;
  58 import org.opendaylight.restconf.common.patch.PatchEntity;
  59 import org.opendaylight.restconf.common.patch.PatchStatusContext;
  60 import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils;
  61 import org.opendaylight.restconf.nb.rfc8040.handlers.ActionServiceHandler;
  62 import org.opendaylight.restconf.nb.rfc8040.handlers.DOMMountPointServiceHandler;
  63 import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
  64 import org.opendaylight.restconf.nb.rfc8040.handlers.TransactionChainHandler;
  65 import org.opendaylight.restconf.nb.rfc8040.references.SchemaContextRef;
  66 import org.opendaylight.restconf.nb.rfc8040.rests.services.api.RestconfStreamsSubscriptionService;
  67 import org.opendaylight.yangtools.yang.common.QName;
  68 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  69 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  70 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  71 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  72 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  73 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
  74 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
  75 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
  76 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
  77 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  78 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  79 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
  80 import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
  81 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  82 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  83 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
  84 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
  85
  86 public class RestconfDataServiceImplTest {
  87
  88     private static final String PATH_FOR_NEW_SCHEMA_CONTEXT = "/jukebox";
  89
  90     private ContainerNode buildBaseCont;
  91     private ContainerNode buildBaseContConfig;
  92     private ContainerNode buildBaseContOperational;
  93     private SchemaContextRef contextRef;
  94     private YangInstanceIdentifier iidBase;
  95     private DataSchemaNode schemaNode;
  96     private RestconfDataServiceImpl dataService;
  97     private QName baseQName;
  98     private QName containerPlayerQname;
  99     private QName leafQname;
 100     private ContainerNode buildPlayerCont;
 101     private ContainerNode buildLibraryCont;
 102     private MapNode buildPlaylistList;
 103     private TransactionChainHandler transactionChainHandler;
 104
 105     @Mock
 106     private DOMTransactionChain domTransactionChain;
 107     @Mock
 108     private UriInfo uriInfo;
 109     @Mock
 110     private DOMDataTreeReadWriteTransaction readWrite;
 111     @Mock
 112     private DOMDataTreeReadTransaction read;
 113     @Mock
 114     private DOMDataTreeWriteTransaction write;
 115     @Mock
 116     private DOMMountPointService mountPointService;
 117     @Mock
 118     private DOMMountPoint mountPoint;
 119     @Mock
 120     private DOMDataBroker mountDataBroker;
 121     @Mock
 122     private ActionServiceHandler actionServiceHandler;
 123     @Mock
 124     private DOMTransactionChain mountTransactionChain;
 125     @Mock
 126     private RestconfStreamsSubscriptionService delegRestconfSubscrService;
 127
 128     @Before
 129     public void setUp() throws Exception {
 130         MockitoAnnotations.initMocks(this);
 131
 132         final MultivaluedMap<String, String> value = Mockito.mock(MultivaluedMap.class);
 133         Mockito.when(value.entrySet()).thenReturn(new HashSet<>());
 134         Mockito.when(this.uriInfo.getQueryParameters()).thenReturn(value);
 135
 136         this.baseQName = QName.create("http://example.com/ns/example-jukebox", "2015-04-04", "jukebox");
 137         this.containerPlayerQname = QName.create(this.baseQName, "player");
 138         this.leafQname = QName.create(this.baseQName, "gap");
 139
 140         final QName containerLibraryQName = QName.create(this.baseQName, "library");
 141         final QName listPlaylistQName = QName.create(this.baseQName, "playlist");
 142
 143         final LeafNode buildLeaf = Builders.leafBuilder()
 144                 .withNodeIdentifier(new NodeIdentifier(this.leafQname))
 145                 .withValue(0.2)
 146                 .build();
 147
 148         this.buildPlayerCont = Builders.containerBuilder()
 149                 .withNodeIdentifier(new NodeIdentifier(this.containerPlayerQname))
 150                 .withChild(buildLeaf)
 151                 .build();
 152
 153         this.buildLibraryCont = Builders.containerBuilder()
 154                 .withNodeIdentifier(new NodeIdentifier(containerLibraryQName))
 155                 .build();
 156
 157         this.buildPlaylistList = Builders.mapBuilder()
 158                 .withNodeIdentifier(new NodeIdentifier(listPlaylistQName))
 159                 .build();
 160
 161         this.buildBaseCont = Builders.containerBuilder()
 162                 .withNodeIdentifier(new NodeIdentifier(this.baseQName))
 163                 .withChild(this.buildPlayerCont)
 164                 .build();
 165
 166         // config contains one child the same as in operational and one additional
 167         this.buildBaseContConfig = Builders.containerBuilder()
 168                 .withNodeIdentifier(new NodeIdentifier(this.baseQName))
 169                 .withChild(this.buildPlayerCont)
 170                 .withChild(this.buildLibraryCont)
 171                 .build();
 172
 173         // operational contains one child the same as in config and one additional
 174         this.buildBaseContOperational = Builders.containerBuilder()
 175                 .withNodeIdentifier(new NodeIdentifier(this.baseQName))
 176                 .withChild(this.buildPlayerCont)
 177                 .withChild(this.buildPlaylistList)
 178                 .build();
 179
 180         this.iidBase = YangInstanceIdentifier.builder()
 181                 .node(this.baseQName)
 182                 .build();
 183
 184         this.contextRef = new SchemaContextRef(
 185                 YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles(PATH_FOR_NEW_SCHEMA_CONTEXT)));
 186         this.schemaNode = DataSchemaContextTree.from(this.contextRef.get()).getChild(this.iidBase).getDataSchemaNode();
 187
 188         doReturn(CommitInfo.emptyFluentFuture()).when(this.write).commit();
 189         doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit();
 190
 191         doReturn(this.read).when(domTransactionChain).newReadOnlyTransaction();
 192         doReturn(this.readWrite).when(domTransactionChain).newReadWriteTransaction();
 193         doReturn(this.write).when(domTransactionChain).newWriteOnlyTransaction();
 194
 195         DOMDataBroker mockDataBroker = Mockito.mock(DOMDataBroker.class);
 196         Mockito.doReturn(domTransactionChain).when(mockDataBroker).createTransactionChain(Mockito.any());
 197
 198         transactionChainHandler = new TransactionChainHandler(mockDataBroker);
 199
 200         final SchemaContextHandler schemaContextHandler = new SchemaContextHandler(transactionChainHandler,
 201                 Mockito.mock(DOMSchemaService.class));
 202
 203         schemaContextHandler.onModelContextUpdated(this.contextRef.get());
 204         this.dataService = new RestconfDataServiceImpl(schemaContextHandler, this.transactionChainHandler,
 205                 new DOMMountPointServiceHandler(mountPointService), this.delegRestconfSubscrService,
 206                 this.actionServiceHandler);
 207         doReturn(Optional.of(this.mountPoint)).when(this.mountPointService)
 208                 .getMountPoint(any(YangInstanceIdentifier.class));
 209         doCallRealMethod().when(this.mountPoint).getSchemaContext();
 210         doReturn(this.contextRef.get()).when(this.mountPoint).getEffectiveModelContext();
 211         doReturn(Optional.of(this.mountDataBroker)).when(this.mountPoint).getService(DOMDataBroker.class);
 212         doReturn(this.mountTransactionChain).when(this.mountDataBroker)
 213                 .createTransactionChain(any(DOMTransactionChainListener.class));
 214         doReturn(this.read).when(this.mountTransactionChain).newReadOnlyTransaction();
 215         doReturn(this.readWrite).when(this.mountTransactionChain).newReadWriteTransaction();
 216     }
 217
 218     @Test
 219     public void testReadData() {
 220         doReturn(new MultivaluedHashMap<String, String>()).when(this.uriInfo).getQueryParameters();
 221         doReturn(immediateFluentFuture(Optional.of(this.buildBaseCont))).when(this.read)
 222                 .read(LogicalDatastoreType.CONFIGURATION, this.iidBase);
 223         doReturn(immediateFluentFuture(Optional.empty()))
 224                 .when(this.read).read(LogicalDatastoreType.OPERATIONAL, this.iidBase);
 225         final Response response = this.dataService.readData("example-jukebox:jukebox", this.uriInfo);
 226         assertNotNull(response);
 227         assertEquals(200, response.getStatus());
 228         assertEquals(this.buildBaseCont, ((NormalizedNodeContext) response.getEntity()).getData());
 229     }
 230
 231     @Test
 232     public void testReadRootData() {
 233         doReturn(new MultivaluedHashMap<String, String>()).when(this.uriInfo).getQueryParameters();
 234         doReturn(immediateFluentFuture(Optional.of(wrapNodeByDataRootContainer(this.buildBaseContConfig))))
 235                 .when(this.read)
 236                 .read(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.empty());
 237         doReturn(immediateFluentFuture(Optional.of(wrapNodeByDataRootContainer(this.buildBaseContOperational))))
 238                 .when(this.read)
 239                 .read(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.empty());
 240         final Response response = this.dataService.readData(this.uriInfo);
 241         assertNotNull(response);
 242         assertEquals(200, response.getStatus());
 243
 244         final NormalizedNode<?, ?> data = ((NormalizedNodeContext) response.getEntity()).getData();
 245         assertTrue(data instanceof ContainerNode);
 246         final Collection<DataContainerChild<? extends PathArgument, ?>> rootNodes = ((ContainerNode) data).getValue();
 247         assertEquals(1, rootNodes.size());
 248         final Collection<DataContainerChild<? extends PathArgument, ?>> allDataChildren
 249                 = ((ContainerNode) rootNodes.iterator().next()).getValue();
 250         assertEquals(3, allDataChildren.size());
 251     }
 252
 253     private static ContainerNode wrapNodeByDataRootContainer(final DataContainerChild<?, ?> data) {
 254         return ImmutableContainerNodeBuilder.create()
 255                 .withNodeIdentifier(NodeIdentifier.create(SchemaContext.NAME))
 256                 .withChild(data)
 257                 .build();
 258     }
 259
 260     /**
 261      * Test read data from mount point when both {@link LogicalDatastoreType#CONFIGURATION} and
 262      * {@link LogicalDatastoreType#OPERATIONAL} contains the same data and some additional data to be merged.
 263      */
 264     @Test
 265     public void testReadDataMountPoint() {
 266         doReturn(new MultivaluedHashMap<String, String>()).when(this.uriInfo).getQueryParameters();
 267         doReturn(immediateFluentFuture(Optional.of(this.buildBaseContConfig))).when(this.read)
 268                 .read(LogicalDatastoreType.CONFIGURATION, this.iidBase);
 269         doReturn(immediateFluentFuture(Optional.of(this.buildBaseContOperational))).when(this.read)
 270                 .read(LogicalDatastoreType.OPERATIONAL, this.iidBase);
 271
 272         final Response response = this.dataService.readData(
 273                 "example-jukebox:jukebox/yang-ext:mount/example-jukebox:jukebox", this.uriInfo);
 274
 275         assertNotNull(response);
 276         assertEquals(200, response.getStatus());
 277
 278         // response must contain all child nodes from config and operational containers merged in one container
 279         final NormalizedNode<?, ?> data = ((NormalizedNodeContext) response.getEntity()).getData();
 280         assertTrue(data instanceof ContainerNode);
 281         assertEquals(3, ((ContainerNode) data).getValue().size());
 282         assertTrue(((ContainerNode) data).getChild(this.buildPlayerCont.getIdentifier()).isPresent());
 283         assertTrue(((ContainerNode) data).getChild(this.buildLibraryCont.getIdentifier()).isPresent());
 284         assertTrue(((ContainerNode) data).getChild(this.buildPlaylistList.getIdentifier()).isPresent());
 285     }
 286
 287     @Test(expected = RestconfDocumentedException.class)
 288     public void testReadDataNoData() {
 289         doReturn(new MultivaluedHashMap<String, String>()).when(this.uriInfo).getQueryParameters();
 290         doReturn(immediateFluentFuture(Optional.empty()))
 291                 .when(this.read).read(LogicalDatastoreType.CONFIGURATION, this.iidBase);
 292         doReturn(immediateFluentFuture(Optional.empty()))
 293                 .when(this.read).read(LogicalDatastoreType.OPERATIONAL, this.iidBase);
 294         this.dataService.readData("example-jukebox:jukebox", this.uriInfo);
 295     }
 296
 297     /**
 298      * Read data from config datastore according to content parameter.
 299      */
 300     @Test
 301     public void testReadDataConfigTest() {
 302         final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
 303         parameters.put("content", Collections.singletonList("config"));
 304
 305         doReturn(parameters).when(this.uriInfo).getQueryParameters();
 306         doReturn(immediateFluentFuture(Optional.of(this.buildBaseContConfig))).when(this.read)
 307                 .read(LogicalDatastoreType.CONFIGURATION, this.iidBase);
 308         doReturn(immediateFluentFuture(Optional.of(this.buildBaseContOperational))).when(this.read)
 309                 .read(LogicalDatastoreType.OPERATIONAL, this.iidBase);
 310
 311         final Response response = this.dataService.readData("example-jukebox:jukebox", this.uriInfo);
 312
 313         assertNotNull(response);
 314         assertEquals(200, response.getStatus());
 315
 316         // response must contain only config data
 317         final NormalizedNode<?, ?> data = ((NormalizedNodeContext) response.getEntity()).getData();
 318
 319         // config data present
 320         assertTrue(((ContainerNode) data).getChild(this.buildPlayerCont.getIdentifier()).isPresent());
 321         assertTrue(((ContainerNode) data).getChild(this.buildLibraryCont.getIdentifier()).isPresent());
 322
 323         // state data absent
 324         assertFalse(((ContainerNode) data).getChild(this.buildPlaylistList.getIdentifier()).isPresent());
 325     }
 326
 327     /**
 328      * Read data from operational datastore according to content parameter.
 329      */
 330     @Test
 331     public void testReadDataOperationalTest() {
 332         final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
 333         parameters.put("content", Collections.singletonList("nonconfig"));
 334
 335         doReturn(parameters).when(this.uriInfo).getQueryParameters();
 336         doReturn(immediateFluentFuture(Optional.of(this.buildBaseContConfig))).when(this.read)
 337                 .read(LogicalDatastoreType.CONFIGURATION, this.iidBase);
 338         doReturn(immediateFluentFuture(Optional.of(this.buildBaseContOperational))).when(this.read)
 339                 .read(LogicalDatastoreType.OPERATIONAL, this.iidBase);
 340
 341         final Response response = this.dataService.readData("example-jukebox:jukebox", this.uriInfo);
 342
 343         assertNotNull(response);
 344         assertEquals(200, response.getStatus());
 345
 346         // response must contain only operational data
 347         final NormalizedNode<?, ?> data = ((NormalizedNodeContext) response.getEntity()).getData();
 348
 349         // state data present
 350         assertTrue(((ContainerNode) data).getChild(this.buildPlayerCont.getIdentifier()).isPresent());
 351         assertTrue(((ContainerNode) data).getChild(this.buildPlaylistList.getIdentifier()).isPresent());
 352
 353         // config data absent
 354         assertFalse(((ContainerNode) data).getChild(this.buildLibraryCont.getIdentifier()).isPresent());
 355     }
 356
 357     @Test
 358     public void testPutData() {
 359         final InstanceIdentifierContext<DataSchemaNode> iidContext =
 360                 new InstanceIdentifierContext<>(this.iidBase, this.schemaNode, null, this.contextRef.get());
 361         final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseCont);
 362
 363         doReturn(immediateTrueFluentFuture()).when(this.readWrite)
 364                 .exists(LogicalDatastoreType.CONFIGURATION, this.iidBase);
 365         doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, this.iidBase, payload.getData());
 366         final Response response = this.dataService.putData(null, payload, this.uriInfo);
 367         assertNotNull(response);
 368         assertEquals(Response.Status.NO_CONTENT.getStatusCode(), response.getStatus());
 369     }
 370
 371     @Test
 372     public void testPutDataWithMountPoint() {
 373 //        final DOMDataBroker dataBroker = Mockito.mock(DOMDataBroker.class);
 374 //        doReturn(Optional.of(dataBroker)).when(mountPoint).getService(DOMDataBroker.class);
 375 //        doReturn(this.transactionChainHandler.get()).when(dataBroker)
 376 //                .createTransactionChain(RestConnectorProvider.TRANSACTION_CHAIN_LISTENER);
 377         final InstanceIdentifierContext<DataSchemaNode> iidContext =
 378                 new InstanceIdentifierContext<>(this.iidBase, this.schemaNode, mountPoint, this.contextRef.get());
 379         final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseCont);
 380
 381         doReturn(immediateTrueFluentFuture()).when(this.readWrite)
 382                 .exists(LogicalDatastoreType.CONFIGURATION, this.iidBase);
 383         doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, this.iidBase, payload.getData());
 384         final Response response = this.dataService.putData(null, payload, this.uriInfo);
 385         assertNotNull(response);
 386         assertEquals(Response.Status.NO_CONTENT.getStatusCode(), response.getStatus());
 387     }
 388
 389     @Test
 390     public void testPostData() {
 391         final QName listQname = QName.create(this.baseQName, "playlist");
 392         final QName listKeyQname = QName.create(this.baseQName, "name");
 393         final NodeIdentifierWithPredicates nodeWithKey =
 394                 NodeIdentifierWithPredicates.of(listQname, listKeyQname, "name of band");
 395         final LeafNode<Object> content = Builders.leafBuilder()
 396                 .withNodeIdentifier(new NodeIdentifier(QName.create(this.baseQName, "name")))
 397                 .withValue("name of band")
 398                 .build();
 399         final LeafNode<Object> content2 = Builders.leafBuilder()
 400             .withNodeIdentifier(new NodeIdentifier(QName.create(this.baseQName, "description")))
 401             .withValue("band description")
 402             .build();
 403         final MapEntryNode mapEntryNode = Builders.mapEntryBuilder()
 404                 .withNodeIdentifier(nodeWithKey)
 405                 .withChild(content)
 406                 .withChild(content2)
 407                 .build();
 408         final MapNode buildList = Builders.mapBuilder()
 409                 .withNodeIdentifier(new NodeIdentifier(listQname))
 410                 .withChild(mapEntryNode)
 411                 .build();
 412
 413         doReturn(new MultivaluedHashMap<String, String>()).when(this.uriInfo).getQueryParameters();
 414         final InstanceIdentifierContext<? extends SchemaNode> iidContext =
 415                 new InstanceIdentifierContext<>(this.iidBase, null, null, this.contextRef.get());
 416         final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, buildList);
 417         doReturn(immediateFluentFuture(Optional.empty()))
 418                 .when(this.read).read(LogicalDatastoreType.CONFIGURATION, this.iidBase);
 419         final MapNode data = (MapNode) payload.getData();
 420         final NodeIdentifierWithPredicates identifier =
 421                 data.getValue().iterator().next().getIdentifier();
 422         final YangInstanceIdentifier node =
 423                 payload.getInstanceIdentifierContext().getInstanceIdentifier().node(identifier);
 424         doReturn(immediateFalseFluentFuture())
 425                 .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, node);
 426         doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, node, payload.getData());
 427         doReturn(UriBuilder.fromUri("http://localhost:8181/restconf/15/")).when(this.uriInfo).getBaseUriBuilder();
 428
 429         final Response response = this.dataService.postData(null, payload, this.uriInfo);
 430         assertEquals(201, response.getStatus());
 431     }
 432
 433     @Test
 434     public void testDeleteData() {
 435         doNothing().when(this.readWrite).delete(LogicalDatastoreType.CONFIGURATION, this.iidBase);
 436         doReturn(immediateTrueFluentFuture())
 437                 .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iidBase);
 438         final Response response = this.dataService.deleteData("example-jukebox:jukebox");
 439         assertNotNull(response);
 440         assertEquals(Response.Status.NO_CONTENT.getStatusCode(), response.getStatus());
 441     }
 442
 443     /**
 444      * Test of deleting data on mount point.
 445      */
 446     @Test
 447     public void testDeleteDataMountPoint() {
 448         doNothing().when(this.readWrite).delete(LogicalDatastoreType.CONFIGURATION, this.iidBase);
 449         doReturn(immediateTrueFluentFuture())
 450                 .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iidBase);
 451         final Response response =
 452                 this.dataService.deleteData("example-jukebox:jukebox/yang-ext:mount/example-jukebox:jukebox");
 453         assertNotNull(response);
 454         assertEquals(Response.Status.NO_CONTENT.getStatusCode(), response.getStatus());
 455     }
 456
 457     @Test
 458     public void testPatchData() throws Exception {
 459         final InstanceIdentifierContext<? extends SchemaNode> iidContext =
 460                 new InstanceIdentifierContext<>(this.iidBase, this.schemaNode, null, this.contextRef.get());
 461         final List<PatchEntity> entity = new ArrayList<>();
 462         final YangInstanceIdentifier iidleaf = YangInstanceIdentifier.builder(this.iidBase)
 463                 .node(this.containerPlayerQname)
 464                 .node(this.leafQname)
 465                 .build();
 466         entity.add(new PatchEntity("create data", CREATE, this.iidBase, this.buildBaseCont));
 467         entity.add(new PatchEntity("replace data", REPLACE, this.iidBase, this.buildBaseCont));
 468         entity.add(new PatchEntity("delete data", DELETE, iidleaf));
 469         final PatchContext patch = new PatchContext(iidContext, entity, "test patch id");
 470
 471         doReturn(immediateFluentFuture(Optional.of(this.buildBaseCont))).when(this.read)
 472                 .read(LogicalDatastoreType.CONFIGURATION, this.iidBase);
 473         doNothing().when(this.write).put(LogicalDatastoreType.CONFIGURATION, this.iidBase, this.buildBaseCont);
 474         doNothing().when(this.readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidleaf);
 475         doReturn(immediateFalseFluentFuture())
 476                 .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iidBase);
 477         doReturn(immediateTrueFluentFuture())
 478                 .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidleaf);
 479         final PatchStatusContext status = this.dataService.patchData(patch, this.uriInfo);
 480         assertTrue(status.isOk());
 481         assertEquals(3, status.getEditCollection().size());
 482         assertEquals("replace data", status.getEditCollection().get(1).getEditId());
 483     }
 484
 485     @Test
 486     public void testPatchDataMountPoint() throws Exception {
 487         final InstanceIdentifierContext<? extends SchemaNode> iidContext = new InstanceIdentifierContext<>(
 488                 this.iidBase, this.schemaNode, this.mountPoint, this.contextRef.get());
 489         final List<PatchEntity> entity = new ArrayList<>();
 490         final YangInstanceIdentifier iidleaf = YangInstanceIdentifier.builder(this.iidBase)
 491                 .node(this.containerPlayerQname)
 492                 .node(this.leafQname)
 493                 .build();
 494         entity.add(new PatchEntity("create data", CREATE, this.iidBase, this.buildBaseCont));
 495         entity.add(new PatchEntity("replace data", REPLACE, this.iidBase, this.buildBaseCont));
 496         entity.add(new PatchEntity("delete data", DELETE, iidleaf));
 497         final PatchContext patch = new PatchContext(iidContext, entity, "test patch id");
 498
 499         doReturn(immediateFluentFuture(Optional.of(this.buildBaseCont))).when(this.read)
 500                 .read(LogicalDatastoreType.CONFIGURATION, this.iidBase);
 501         doNothing().when(this.write).put(LogicalDatastoreType.CONFIGURATION, this.iidBase, this.buildBaseCont);
 502         doNothing().when(this.readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidleaf);
 503         doReturn(immediateFalseFluentFuture())
 504                 .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iidBase);
 505         doReturn(immediateTrueFluentFuture()).when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidleaf);
 506
 507         final PatchStatusContext status = this.dataService.patchData(patch, this.uriInfo);
 508         assertTrue(status.isOk());
 509         assertEquals(3, status.getEditCollection().size());
 510         assertNull(status.getGlobalErrors());
 511     }
 512
 513     @Test
 514     public void testPatchDataDeleteNotExist() throws Exception {
 515         final InstanceIdentifierContext<? extends SchemaNode> iidContext =
 516                 new InstanceIdentifierContext<>(this.iidBase, this.schemaNode, null, this.contextRef.get());
 517         final List<PatchEntity> entity = new ArrayList<>();
 518         final YangInstanceIdentifier iidleaf = YangInstanceIdentifier.builder(this.iidBase)
 519                 .node(this.containerPlayerQname)
 520                 .node(this.leafQname)
 521                 .build();
 522         entity.add(new PatchEntity("create data", CREATE, this.iidBase, this.buildBaseCont));
 523         entity.add(new PatchEntity("remove data", REMOVE, iidleaf));
 524         entity.add(new PatchEntity("delete data", DELETE, iidleaf));
 525         final PatchContext patch = new PatchContext(iidContext, entity, "test patch id");
 526
 527         doReturn(immediateFluentFuture(Optional.of(this.buildBaseCont))).when(this.read)
 528                 .read(LogicalDatastoreType.CONFIGURATION, this.iidBase);
 529         doNothing().when(this.write).put(LogicalDatastoreType.CONFIGURATION, this.iidBase, this.buildBaseCont);
 530         doNothing().when(this.readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidleaf);
 531         doReturn(immediateFalseFluentFuture())
 532                 .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iidBase);
 533         doReturn(immediateFalseFluentFuture())
 534                 .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidleaf);
 535         doReturn(true).when(this.readWrite).cancel();
 536         final PatchStatusContext status = this.dataService.patchData(patch, this.uriInfo);
 537
 538         assertFalse(status.isOk());
 539         assertEquals(3, status.getEditCollection().size());
 540         assertTrue(status.getEditCollection().get(0).isOk());
 541         assertTrue(status.getEditCollection().get(1).isOk());
 542         assertFalse(status.getEditCollection().get(2).isOk());
 543         assertFalse(status.getEditCollection().get(2).getEditErrors().isEmpty());
 544         final String errorMessage = status.getEditCollection().get(2).getEditErrors().get(0).getErrorMessage();
 545         assertEquals("Data does not exist", errorMessage);
 546     }
 547 }