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