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