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.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.SchemaContextHandler;
  62 import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload;
  63 import org.opendaylight.restconf.nb.rfc8040.rests.services.api.RestconfStreamsSubscriptionService;
  64 import org.opendaylight.restconf.nb.rfc8040.rests.transactions.MdsalRestconfStrategy;
  65 import org.opendaylight.restconf.nb.rfc8040.rests.transactions.NetconfRestconfStrategy;
  66 import org.opendaylight.restconf.nb.rfc8040.rests.transactions.RestconfStrategy;
  67 import org.opendaylight.restconf.nb.rfc8040.streams.Configuration;
  68 import org.opendaylight.yangtools.yang.common.QName;
  69 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  70 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  71 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  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.ImmutableNodes;
  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(uriInfo).getQueryParameters();
 138
 139         baseQName = QName.create("http://example.com/ns/example-jukebox", "2015-04-04", "jukebox");
 140         containerPlayerQname = QName.create(baseQName, "player");
 141         leafQname = QName.create(baseQName, "gap");
 142
 143         final QName containerLibraryQName = QName.create(baseQName, "library");
 144         final QName listPlaylistQName = QName.create(baseQName, "playlist");
 145
 146         final LeafNode<?> buildLeaf = Builders.leafBuilder()
 147                 .withNodeIdentifier(new NodeIdentifier(leafQname))
 148                 .withValue(0.2)
 149                 .build();
 150
 151         buildPlayerCont = Builders.containerBuilder()
 152                 .withNodeIdentifier(new NodeIdentifier(containerPlayerQname))
 153                 .withChild(buildLeaf)
 154                 .build();
 155
 156         buildLibraryCont = Builders.containerBuilder()
 157                 .withNodeIdentifier(new NodeIdentifier(containerLibraryQName))
 158                 .build();
 159
 160         buildPlaylistList = Builders.mapBuilder()
 161                 .withNodeIdentifier(new NodeIdentifier(listPlaylistQName))
 162                 .build();
 163
 164         buildBaseCont = Builders.containerBuilder()
 165                 .withNodeIdentifier(new NodeIdentifier(baseQName))
 166                 .withChild(buildPlayerCont)
 167                 .build();
 168
 169         // config contains one child the same as in operational and one additional
 170         buildBaseContConfig = Builders.containerBuilder()
 171                 .withNodeIdentifier(new NodeIdentifier(baseQName))
 172                 .withChild(buildPlayerCont)
 173                 .withChild(buildLibraryCont)
 174                 .build();
 175
 176         // operational contains one child the same as in config and one additional
 177         buildBaseContOperational = Builders.containerBuilder()
 178                 .withNodeIdentifier(new NodeIdentifier(baseQName))
 179                 .withChild(buildPlayerCont)
 180                 .withChild(buildPlaylistList)
 181                 .build();
 182
 183         iidBase = YangInstanceIdentifier.builder()
 184                 .node(baseQName)
 185                 .build();
 186
 187         contextRef =
 188                 YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles(PATH_FOR_NEW_SCHEMA_CONTEXT));
 189         schemaNode = DataSchemaContextTree.from(contextRef).findChild(iidBase).orElseThrow(
 190             ).getDataSchemaNode();
 191
 192         doReturn(CommitInfo.emptyFluentFuture()).when(write).commit();
 193         doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
 194
 195         DOMDataBroker mockDataBroker = mock(DOMDataBroker.class);
 196         doReturn(read).when(mockDataBroker).newReadOnlyTransaction();
 197         doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction();
 198         doReturn(write).when(mockDataBroker).newWriteOnlyTransaction();
 199
 200         final SchemaContextHandler schemaContextHandler = new SchemaContextHandler(
 201                 mockDataBroker, mock(DOMSchemaService.class));
 202
 203         schemaContextHandler.onModelContextUpdated(contextRef);
 204         dataService = new RestconfDataServiceImpl(schemaContextHandler, mockDataBroker, mountPointService,
 205                 delegRestconfSubscrService, actionService, configuration);
 206         doReturn(Optional.of(mountPoint)).when(mountPointService)
 207                 .getMountPoint(any(YangInstanceIdentifier.class));
 208         doReturn(Optional.of(FixedDOMSchemaService.of(contextRef))).when(mountPoint)
 209                 .getService(DOMSchemaService.class);
 210         doReturn(Optional.of(mountDataBroker)).when(mountPoint).getService(DOMDataBroker.class);
 211         doReturn(Optional.empty()).when(mountPoint).getService(NetconfDataTreeService.class);
 212         doReturn(read).when(mountDataBroker).newReadOnlyTransaction();
 213         doReturn(readWrite).when(mountDataBroker).newReadWriteTransaction();
 214     }
 215
 216     @Test
 217     public void testReadData() {
 218         doReturn(new MultivaluedHashMap<String, String>()).when(uriInfo).getQueryParameters();
 219         doReturn(immediateFluentFuture(Optional.of(buildBaseCont))).when(read)
 220                 .read(LogicalDatastoreType.CONFIGURATION, iidBase);
 221         doReturn(immediateFluentFuture(Optional.empty()))
 222                 .when(read).read(LogicalDatastoreType.OPERATIONAL, iidBase);
 223         final Response response = dataService.readData("example-jukebox:jukebox", uriInfo);
 224         assertNotNull(response);
 225         assertEquals(200, response.getStatus());
 226         assertEquals(buildBaseCont, ((NormalizedNodePayload) response.getEntity()).getData());
 227     }
 228
 229     @Test
 230     public void testReadRootData() {
 231         doReturn(new MultivaluedHashMap<String, String>()).when(uriInfo).getQueryParameters();
 232         doReturn(immediateFluentFuture(Optional.of(wrapNodeByDataRootContainer(buildBaseContConfig))))
 233                 .when(read)
 234                 .read(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.empty());
 235         doReturn(immediateFluentFuture(Optional.of(wrapNodeByDataRootContainer(buildBaseContOperational))))
 236                 .when(read)
 237                 .read(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.empty());
 238         final Response response = dataService.readData(uriInfo);
 239         assertNotNull(response);
 240         assertEquals(200, response.getStatus());
 241
 242         final NormalizedNode data = ((NormalizedNodePayload) response.getEntity()).getData();
 243         assertTrue(data instanceof ContainerNode);
 244         final Collection<DataContainerChild> rootNodes = ((ContainerNode) data).body();
 245         assertEquals(1, rootNodes.size());
 246         final Collection<DataContainerChild> allDataChildren = ((ContainerNode) rootNodes.iterator().next()).body();
 247         assertEquals(3, allDataChildren.size());
 248     }
 249
 250     private static ContainerNode wrapNodeByDataRootContainer(final DataContainerChild data) {
 251         return ImmutableContainerNodeBuilder.create()
 252                 .withNodeIdentifier(NodeIdentifier.create(SchemaContext.NAME))
 253                 .withChild(data)
 254                 .build();
 255     }
 256
 257     /**
 258      * Test read data from mount point when both {@link LogicalDatastoreType#CONFIGURATION} and
 259      * {@link LogicalDatastoreType#OPERATIONAL} contains the same data and some additional data to be merged.
 260      */
 261     @Test
 262     public void testReadDataMountPoint() {
 263         doReturn(new MultivaluedHashMap<String, String>()).when(uriInfo).getQueryParameters();
 264         doReturn(immediateFluentFuture(Optional.of(buildBaseContConfig))).when(read)
 265                 .read(LogicalDatastoreType.CONFIGURATION, iidBase);
 266         doReturn(immediateFluentFuture(Optional.of(buildBaseContOperational))).when(read)
 267                 .read(LogicalDatastoreType.OPERATIONAL, iidBase);
 268
 269         final Response response = dataService.readData(
 270                 "example-jukebox:jukebox/yang-ext:mount/example-jukebox:jukebox", uriInfo);
 271
 272         assertNotNull(response);
 273         assertEquals(200, response.getStatus());
 274
 275         // response must contain all child nodes from config and operational containers merged in one container
 276         final NormalizedNode data = ((NormalizedNodePayload) response.getEntity()).getData();
 277         assertTrue(data instanceof ContainerNode);
 278         assertEquals(3, ((ContainerNode) data).size());
 279         assertTrue(((ContainerNode) data).findChildByArg(buildPlayerCont.getIdentifier()).isPresent());
 280         assertTrue(((ContainerNode) data).findChildByArg(buildLibraryCont.getIdentifier()).isPresent());
 281         assertTrue(((ContainerNode) data).findChildByArg(buildPlaylistList.getIdentifier()).isPresent());
 282     }
 283
 284     @Test(expected = RestconfDocumentedException.class)
 285     public void testReadDataNoData() {
 286         doReturn(new MultivaluedHashMap<String, String>()).when(uriInfo).getQueryParameters();
 287         doReturn(immediateFluentFuture(Optional.empty()))
 288                 .when(read).read(LogicalDatastoreType.CONFIGURATION, iidBase);
 289         doReturn(immediateFluentFuture(Optional.empty()))
 290                 .when(read).read(LogicalDatastoreType.OPERATIONAL, iidBase);
 291         dataService.readData("example-jukebox:jukebox", uriInfo);
 292     }
 293
 294     /**
 295      * Read data from config datastore according to content parameter.
 296      */
 297     @Test
 298     public void testReadDataConfigTest() {
 299         final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
 300         parameters.put("content", List.of("config"));
 301
 302         doReturn(parameters).when(uriInfo).getQueryParameters();
 303         doReturn(immediateFluentFuture(Optional.of(buildBaseContConfig))).when(read)
 304                 .read(LogicalDatastoreType.CONFIGURATION, iidBase);
 305
 306         final Response response = dataService.readData("example-jukebox:jukebox", uriInfo);
 307
 308         assertNotNull(response);
 309         assertEquals(200, response.getStatus());
 310
 311         // response must contain only config data
 312         final NormalizedNode data = ((NormalizedNodePayload) response.getEntity()).getData();
 313
 314         // config data present
 315         assertTrue(((ContainerNode) data).findChildByArg(buildPlayerCont.getIdentifier()).isPresent());
 316         assertTrue(((ContainerNode) data).findChildByArg(buildLibraryCont.getIdentifier()).isPresent());
 317
 318         // state data absent
 319         assertFalse(((ContainerNode) data).findChildByArg(buildPlaylistList.getIdentifier()).isPresent());
 320     }
 321
 322     /**
 323      * Read data from operational datastore according to content parameter.
 324      */
 325     @Test
 326     public void testReadDataOperationalTest() {
 327         final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
 328         parameters.put("content", List.of("nonconfig"));
 329
 330         doReturn(parameters).when(uriInfo).getQueryParameters();
 331         doReturn(immediateFluentFuture(Optional.of(buildBaseContOperational))).when(read)
 332                 .read(LogicalDatastoreType.OPERATIONAL, iidBase);
 333
 334         final Response response = dataService.readData("example-jukebox:jukebox", uriInfo);
 335
 336         assertNotNull(response);
 337         assertEquals(200, response.getStatus());
 338
 339         // response must contain only operational data
 340         final NormalizedNode data = ((NormalizedNodePayload) response.getEntity()).getData();
 341
 342         // state data present
 343         assertTrue(((ContainerNode) data).findChildByArg(buildPlayerCont.getIdentifier()).isPresent());
 344         assertTrue(((ContainerNode) data).findChildByArg(buildPlaylistList.getIdentifier()).isPresent());
 345
 346         // config data absent
 347         assertFalse(((ContainerNode) data).findChildByArg(buildLibraryCont.getIdentifier()).isPresent());
 348     }
 349
 350     @Test
 351     public void testPutData() {
 352         final InstanceIdentifierContext<DataSchemaNode> iidContext =
 353                 new InstanceIdentifierContext<>(iidBase, schemaNode, null, contextRef);
 354         final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseCont);
 355
 356         doReturn(immediateTrueFluentFuture()).when(read)
 357                 .exists(LogicalDatastoreType.CONFIGURATION, iidBase);
 358         doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, iidBase, payload.getData());
 359         final Response response = dataService.putData(null, payload, uriInfo);
 360         assertNotNull(response);
 361         assertEquals(Response.Status.NO_CONTENT.getStatusCode(), response.getStatus());
 362     }
 363
 364     @Test
 365     public void testPutDataWithMountPoint() {
 366         final InstanceIdentifierContext<DataSchemaNode> iidContext =
 367                 new InstanceIdentifierContext<>(iidBase, schemaNode, mountPoint, contextRef);
 368         final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseCont);
 369
 370         doReturn(immediateTrueFluentFuture()).when(read)
 371                 .exists(LogicalDatastoreType.CONFIGURATION, iidBase);
 372         doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, iidBase, payload.getData());
 373         final Response response = dataService.putData(null, payload, uriInfo);
 374         assertNotNull(response);
 375         assertEquals(Response.Status.NO_CONTENT.getStatusCode(), response.getStatus());
 376     }
 377
 378     @Test
 379     public void testPostData() {
 380         final QName listQname = QName.create(baseQName, "playlist");
 381         final QName listKeyQname = QName.create(baseQName, "name");
 382         final NodeIdentifierWithPredicates nodeWithKey =
 383                 NodeIdentifierWithPredicates.of(listQname, listKeyQname, "name of band");
 384
 385         doReturn(new MultivaluedHashMap<String, String>()).when(uriInfo).getQueryParameters();
 386         final InstanceIdentifierContext<? extends SchemaNode> iidContext =
 387                 new InstanceIdentifierContext<>(iidBase, null, null, contextRef);
 388         final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, Builders.mapBuilder()
 389             .withNodeIdentifier(new NodeIdentifier(listQname))
 390             .withChild(Builders.mapEntryBuilder()
 391                 .withNodeIdentifier(nodeWithKey)
 392                 .withChild(ImmutableNodes.leafNode(QName.create(baseQName, "name"), "name of band"))
 393                 .withChild(ImmutableNodes.leafNode(QName.create(baseQName, "description"), "band description"))
 394                 .build())
 395             .build());
 396         final MapNode data = (MapNode) payload.getData();
 397         final MapEntryNode entryNode = data.body().iterator().next();
 398         final NodeIdentifierWithPredicates identifier = entryNode.getIdentifier();
 399         final YangInstanceIdentifier node =
 400                 payload.getInstanceIdentifierContext().getInstanceIdentifier().node(identifier);
 401         doReturn(immediateFalseFluentFuture())
 402                 .when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, node);
 403         doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, node, entryNode);
 404         doReturn(UriBuilder.fromUri("http://localhost:8181/restconf/15/")).when(uriInfo).getBaseUriBuilder();
 405
 406         final Response response = dataService.postData(null, payload, uriInfo);
 407         assertEquals(201, response.getStatus());
 408     }
 409
 410     @Test
 411     public void testDeleteData() {
 412         doNothing().when(readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidBase);
 413         doReturn(immediateTrueFluentFuture())
 414                 .when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidBase);
 415         final Response response = dataService.deleteData("example-jukebox:jukebox");
 416         assertNotNull(response);
 417         assertEquals(Response.Status.NO_CONTENT.getStatusCode(), response.getStatus());
 418     }
 419
 420     /**
 421      * Test of deleting data on mount point.
 422      */
 423     @Test
 424     public void testDeleteDataMountPoint() {
 425         doNothing().when(readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidBase);
 426         doReturn(immediateTrueFluentFuture())
 427                 .when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidBase);
 428         final Response response =
 429                 dataService.deleteData("example-jukebox:jukebox/yang-ext:mount/example-jukebox:jukebox");
 430         assertNotNull(response);
 431         assertEquals(Response.Status.NO_CONTENT.getStatusCode(), response.getStatus());
 432     }
 433
 434     @Test
 435     public void testPatchData() {
 436         final InstanceIdentifierContext<? extends SchemaNode> iidContext =
 437                 new InstanceIdentifierContext<>(iidBase, schemaNode, null, contextRef);
 438         final List<PatchEntity> entity = new ArrayList<>();
 439         final YangInstanceIdentifier iidleaf = YangInstanceIdentifier.builder(iidBase)
 440                 .node(containerPlayerQname)
 441                 .node(leafQname)
 442                 .build();
 443         entity.add(new PatchEntity("create data", CREATE, iidBase, buildBaseCont));
 444         entity.add(new PatchEntity("replace data", REPLACE, iidBase, buildBaseCont));
 445         entity.add(new PatchEntity("delete data", DELETE, iidleaf));
 446         final PatchContext patch = new PatchContext(iidContext, entity, "test patch id");
 447
 448         doNothing().when(readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidleaf);
 449         doReturn(immediateFalseFluentFuture())
 450                 .when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidBase);
 451         doReturn(immediateTrueFluentFuture())
 452                 .when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidleaf);
 453         final PatchStatusContext status = dataService.patchData(patch, uriInfo);
 454         assertTrue(status.isOk());
 455         assertEquals(3, status.getEditCollection().size());
 456         assertEquals("replace data", status.getEditCollection().get(1).getEditId());
 457     }
 458
 459     @Test
 460     public void testPatchDataMountPoint() throws Exception {
 461         final InstanceIdentifierContext<? extends SchemaNode> iidContext = new InstanceIdentifierContext<>(
 462                 iidBase, schemaNode, mountPoint, contextRef);
 463         final List<PatchEntity> entity = new ArrayList<>();
 464         final YangInstanceIdentifier iidleaf = YangInstanceIdentifier.builder(iidBase)
 465                 .node(containerPlayerQname)
 466                 .node(leafQname)
 467                 .build();
 468         entity.add(new PatchEntity("create data", CREATE, iidBase, buildBaseCont));
 469         entity.add(new PatchEntity("replace data", REPLACE, iidBase, buildBaseCont));
 470         entity.add(new PatchEntity("delete data", DELETE, iidleaf));
 471         final PatchContext patch = new PatchContext(iidContext, entity, "test patch id");
 472
 473         doNothing().when(readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidleaf);
 474         doReturn(immediateFalseFluentFuture())
 475                 .when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidBase);
 476         doReturn(immediateTrueFluentFuture()).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidleaf);
 477
 478         final PatchStatusContext status = dataService.patchData(patch, uriInfo);
 479         assertTrue(status.isOk());
 480         assertEquals(3, status.getEditCollection().size());
 481         assertNull(status.getGlobalErrors());
 482     }
 483
 484     @Test
 485     public void testPatchDataDeleteNotExist() {
 486         final InstanceIdentifierContext<? extends SchemaNode> iidContext =
 487                 new InstanceIdentifierContext<>(iidBase, schemaNode, null, contextRef);
 488         final List<PatchEntity> entity = new ArrayList<>();
 489         final YangInstanceIdentifier iidleaf = YangInstanceIdentifier.builder(iidBase)
 490                 .node(containerPlayerQname)
 491                 .node(leafQname)
 492                 .build();
 493         entity.add(new PatchEntity("create data", CREATE, iidBase, buildBaseCont));
 494         entity.add(new PatchEntity("remove data", REMOVE, iidleaf));
 495         entity.add(new PatchEntity("delete data", DELETE, iidleaf));
 496         final PatchContext patch = new PatchContext(iidContext, entity, "test patch id");
 497
 498         doNothing().when(readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidleaf);
 499         doReturn(immediateFalseFluentFuture())
 500                 .when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidBase);
 501         doReturn(immediateFalseFluentFuture())
 502                 .when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidleaf);
 503         doReturn(true).when(readWrite).cancel();
 504         final PatchStatusContext status = dataService.patchData(patch, uriInfo);
 505
 506         assertFalse(status.isOk());
 507         assertEquals(3, status.getEditCollection().size());
 508         assertTrue(status.getEditCollection().get(0).isOk());
 509         assertTrue(status.getEditCollection().get(1).isOk());
 510         assertFalse(status.getEditCollection().get(2).isOk());
 511         assertFalse(status.getEditCollection().get(2).getEditErrors().isEmpty());
 512         final String errorMessage = status.getEditCollection().get(2).getEditErrors().get(0).getErrorMessage();
 513         assertEquals("Data does not exist", errorMessage);
 514     }
 515
 516     @Test
 517     public void testGetRestconfStrategy() {
 518         RestconfStrategy restconfStrategy = dataService.getRestconfStrategy(mountPoint);
 519         assertTrue(restconfStrategy instanceof MdsalRestconfStrategy);
 520
 521         doReturn(Optional.of(netconfService)).when(mountPoint).getService(NetconfDataTreeService.class);
 522         restconfStrategy = dataService.getRestconfStrategy(mountPoint);
 523         assertTrue(restconfStrategy instanceof NetconfRestconfStrategy);
 524     }
 525 }