restconf/restconf-nb/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.assertThrows;
  15 import static org.junit.Assert.assertTrue;
  16 import static org.mockito.ArgumentMatchers.any;
  17 import static org.mockito.Mockito.doNothing;
  18 import static org.mockito.Mockito.doReturn;
  19 import static org.mockito.Mockito.mock;
  20 import static org.opendaylight.restconf.common.patch.PatchEditOperation.CREATE;
  21 import static org.opendaylight.restconf.common.patch.PatchEditOperation.DELETE;
  22 import static org.opendaylight.restconf.common.patch.PatchEditOperation.REMOVE;
  23 import static org.opendaylight.restconf.common.patch.PatchEditOperation.REPLACE;
  24 import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFalseFluentFuture;
  25 import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFluentFuture;
  26 import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateTrueFluentFuture;
  27
  28 import java.util.ArrayList;
  29 import java.util.Collection;
  30 import java.util.List;
  31 import java.util.Optional;
  32 import java.util.Set;
  33 import javax.ws.rs.core.MultivaluedHashMap;
  34 import javax.ws.rs.core.MultivaluedMap;
  35 import javax.ws.rs.core.Response;
  36 import javax.ws.rs.core.UriBuilder;
  37 import javax.ws.rs.core.UriInfo;
  38 import org.junit.Before;
  39 import org.junit.Test;
  40 import org.junit.runner.RunWith;
  41 import org.mockito.Mock;
  42 import org.mockito.junit.MockitoJUnitRunner;
  43 import org.opendaylight.mdsal.common.api.CommitInfo;
  44 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  45 import org.opendaylight.mdsal.dom.api.DOMActionService;
  46 import org.opendaylight.mdsal.dom.api.DOMDataBroker;
  47 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
  48 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
  49 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
  50 import org.opendaylight.mdsal.dom.api.DOMMountPoint;
  51 import org.opendaylight.mdsal.dom.api.DOMMountPointService;
  52 import org.opendaylight.mdsal.dom.api.DOMSchemaService;
  53 import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
  54 import org.opendaylight.mdsal.dom.spi.FixedDOMSchemaService;
  55 import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
  56 import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
  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.legacy.NormalizedNodePayload;
  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.ErrorTag;
  70 import org.opendaylight.yangtools.yang.common.ErrorType;
  71 import org.opendaylight.yangtools.yang.common.QName;
  72 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  73 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  74 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  75 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  76 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
  77 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
  78 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
  79 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
  80 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  81 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  82 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  83 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
  84 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  85 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
  86
  87 @RunWith(MockitoJUnitRunner.StrictStubs.class)
  88 public class RestconfDataServiceImplTest {
  89
  90     private static final String PATH_FOR_NEW_SCHEMA_CONTEXT = "/jukebox";
  91
  92     private ContainerNode buildBaseCont;
  93     private ContainerNode buildBaseContConfig;
  94     private ContainerNode buildBaseContOperational;
  95     private EffectiveModelContext contextRef;
  96     private YangInstanceIdentifier iidBase;
  97     private RestconfDataServiceImpl dataService;
  98     private QName baseQName;
  99     private QName containerPlayerQname;
 100     private QName leafQname;
 101     private ContainerNode buildPlayerCont;
 102     private ContainerNode buildLibraryCont;
 103     private MapNode buildPlaylistList;
 104
 105     @Mock
 106     private DOMTransactionChain domTransactionChain;
 107     @Mock
 108     private UriInfo uriInfo;
 109     @Mock
 110     private DOMDataTreeReadWriteTransaction readWrite;
 111     @Mock
 112     private DOMDataTreeReadTransaction read;
 113     @Mock
 114     private DOMDataTreeWriteTransaction write;
 115     @Mock
 116     private DOMMountPointService mountPointService;
 117     @Mock
 118     private DOMMountPoint mountPoint;
 119     @Mock
 120     private DOMDataBroker mountDataBroker;
 121     @Mock
 122     private NetconfDataTreeService netconfService;
 123     @Mock
 124     private DOMActionService actionService;
 125     @Mock
 126     private RestconfStreamsSubscriptionService delegRestconfSubscrService;
 127     @Mock
 128     private Configuration configuration;
 129     @Mock
 130     private MultivaluedMap<String, String> queryParamenters;
 131
 132     @Before
 133     public void setUp() throws Exception {
 134         doReturn(Set.of()).when(queryParamenters).entrySet();
 135         doReturn(queryParamenters).when(uriInfo).getQueryParameters();
 136
 137         baseQName = QName.create("http://example.com/ns/example-jukebox", "2015-04-04", "jukebox");
 138         containerPlayerQname = QName.create(baseQName, "player");
 139         leafQname = QName.create(baseQName, "gap");
 140
 141         final QName containerLibraryQName = QName.create(baseQName, "library");
 142         final QName listPlaylistQName = QName.create(baseQName, "playlist");
 143
 144         final LeafNode<?> buildLeaf = Builders.leafBuilder()
 145                 .withNodeIdentifier(new NodeIdentifier(leafQname))
 146                 .withValue(0.2)
 147                 .build();
 148
 149         buildPlayerCont = Builders.containerBuilder()
 150                 .withNodeIdentifier(new NodeIdentifier(containerPlayerQname))
 151                 .withChild(buildLeaf)
 152                 .build();
 153
 154         buildLibraryCont = Builders.containerBuilder()
 155                 .withNodeIdentifier(new NodeIdentifier(containerLibraryQName))
 156                 .build();
 157
 158         buildPlaylistList = Builders.mapBuilder()
 159                 .withNodeIdentifier(new NodeIdentifier(listPlaylistQName))
 160                 .build();
 161
 162         buildBaseCont = Builders.containerBuilder()
 163                 .withNodeIdentifier(new NodeIdentifier(baseQName))
 164                 .withChild(buildPlayerCont)
 165                 .build();
 166
 167         // config contains one child the same as in operational and one additional
 168         buildBaseContConfig = Builders.containerBuilder()
 169                 .withNodeIdentifier(new NodeIdentifier(baseQName))
 170                 .withChild(buildPlayerCont)
 171                 .withChild(buildLibraryCont)
 172                 .build();
 173
 174         // operational contains one child the same as in config and one additional
 175         buildBaseContOperational = Builders.containerBuilder()
 176                 .withNodeIdentifier(new NodeIdentifier(baseQName))
 177                 .withChild(buildPlayerCont)
 178                 .withChild(buildPlaylistList)
 179                 .build();
 180
 181         iidBase = YangInstanceIdentifier.builder()
 182                 .node(baseQName)
 183                 .build();
 184
 185         contextRef =
 186                 YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles(PATH_FOR_NEW_SCHEMA_CONTEXT));
 187
 188         doReturn(CommitInfo.emptyFluentFuture()).when(write).commit();
 189         doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
 190
 191         DOMDataBroker mockDataBroker = mock(DOMDataBroker.class);
 192         doReturn(read).when(mockDataBroker).newReadOnlyTransaction();
 193         doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction();
 194         doReturn(write).when(mockDataBroker).newWriteOnlyTransaction();
 195
 196         final SchemaContextHandler schemaContextHandler = new SchemaContextHandler(
 197                 mockDataBroker, mock(DOMSchemaService.class));
 198
 199         schemaContextHandler.onModelContextUpdated(contextRef);
 200         dataService = new RestconfDataServiceImpl(schemaContextHandler, mockDataBroker, mountPointService,
 201                 delegRestconfSubscrService, actionService, configuration);
 202         doReturn(Optional.of(mountPoint)).when(mountPointService)
 203                 .getMountPoint(any(YangInstanceIdentifier.class));
 204         doReturn(Optional.of(FixedDOMSchemaService.of(contextRef))).when(mountPoint)
 205                 .getService(DOMSchemaService.class);
 206         doReturn(Optional.of(mountDataBroker)).when(mountPoint).getService(DOMDataBroker.class);
 207         doReturn(Optional.empty()).when(mountPoint).getService(NetconfDataTreeService.class);
 208         doReturn(read).when(mountDataBroker).newReadOnlyTransaction();
 209         doReturn(readWrite).when(mountDataBroker).newReadWriteTransaction();
 210     }
 211
 212     @Test
 213     public void testReadData() {
 214         doReturn(new MultivaluedHashMap<String, String>()).when(uriInfo).getQueryParameters();
 215         doReturn(immediateFluentFuture(Optional.of(buildBaseCont))).when(read)
 216                 .read(LogicalDatastoreType.CONFIGURATION, iidBase);
 217         doReturn(immediateFluentFuture(Optional.empty()))
 218                 .when(read).read(LogicalDatastoreType.OPERATIONAL, iidBase);
 219         final Response response = dataService.readData("example-jukebox:jukebox", uriInfo);
 220         assertNotNull(response);
 221         assertEquals(200, response.getStatus());
 222         assertEquals(buildBaseCont, ((NormalizedNodePayload) response.getEntity()).getData());
 223     }
 224
 225     @Test
 226     public void testReadRootData() {
 227         doReturn(new MultivaluedHashMap<String, String>()).when(uriInfo).getQueryParameters();
 228         doReturn(immediateFluentFuture(Optional.of(wrapNodeByDataRootContainer(buildBaseContConfig))))
 229                 .when(read)
 230                 .read(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.empty());
 231         doReturn(immediateFluentFuture(Optional.of(wrapNodeByDataRootContainer(buildBaseContOperational))))
 232                 .when(read)
 233                 .read(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.empty());
 234         final Response response = dataService.readData(uriInfo);
 235         assertNotNull(response);
 236         assertEquals(200, response.getStatus());
 237
 238         final NormalizedNode data = ((NormalizedNodePayload) response.getEntity()).getData();
 239         assertTrue(data instanceof ContainerNode);
 240         final Collection<DataContainerChild> rootNodes = ((ContainerNode) data).body();
 241         assertEquals(1, rootNodes.size());
 242         final Collection<DataContainerChild> allDataChildren = ((ContainerNode) rootNodes.iterator().next()).body();
 243         assertEquals(3, allDataChildren.size());
 244     }
 245
 246     private static ContainerNode wrapNodeByDataRootContainer(final DataContainerChild data) {
 247         return Builders.containerBuilder()
 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(uriInfo).getQueryParameters();
 260         doReturn(immediateFluentFuture(Optional.of(buildBaseContConfig))).when(read)
 261                 .read(LogicalDatastoreType.CONFIGURATION, iidBase);
 262         doReturn(immediateFluentFuture(Optional.of(buildBaseContOperational))).when(read)
 263                 .read(LogicalDatastoreType.OPERATIONAL, iidBase);
 264
 265         final Response response = dataService.readData(
 266                 "example-jukebox:jukebox/yang-ext:mount/example-jukebox:jukebox", 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 = ((NormalizedNodePayload) response.getEntity()).getData();
 273         assertTrue(data instanceof ContainerNode);
 274         assertEquals(3, ((ContainerNode) data).size());
 275         assertTrue(((ContainerNode) data).findChildByArg(buildPlayerCont.getIdentifier()).isPresent());
 276         assertTrue(((ContainerNode) data).findChildByArg(buildLibraryCont.getIdentifier()).isPresent());
 277         assertTrue(((ContainerNode) data).findChildByArg(buildPlaylistList.getIdentifier()).isPresent());
 278     }
 279
 280     @Test
 281     public void testReadDataNoData() {
 282         doReturn(new MultivaluedHashMap<String, String>()).when(uriInfo).getQueryParameters();
 283         doReturn(immediateFluentFuture(Optional.empty()))
 284                 .when(read).read(LogicalDatastoreType.CONFIGURATION, iidBase);
 285         doReturn(immediateFluentFuture(Optional.empty()))
 286                 .when(read).read(LogicalDatastoreType.OPERATIONAL, iidBase);
 287
 288         final var errors = assertThrows(RestconfDocumentedException.class,
 289             () -> dataService.readData("example-jukebox:jukebox", uriInfo)).getErrors();
 290         assertEquals(1, errors.size());
 291         final var error = errors.get(0);
 292         assertEquals(ErrorType.PROTOCOL, error.getErrorType());
 293         assertEquals(ErrorTag.DATA_MISSING, error.getErrorTag());
 294         assertEquals("Request could not be completed because the relevant data model content does not exist",
 295             error.getErrorMessage());
 296     }
 297
 298     /**
 299      * Read data from config datastore according to content parameter.
 300      */
 301     @Test
 302     public void testReadDataConfigTest() {
 303         final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
 304         parameters.put("content", List.of("config"));
 305
 306         doReturn(parameters).when(uriInfo).getQueryParameters();
 307         doReturn(immediateFluentFuture(Optional.of(buildBaseContConfig))).when(read)
 308                 .read(LogicalDatastoreType.CONFIGURATION, iidBase);
 309
 310         final Response response = dataService.readData("example-jukebox:jukebox", uriInfo);
 311
 312         assertNotNull(response);
 313         assertEquals(200, response.getStatus());
 314
 315         // response must contain only config data
 316         final NormalizedNode data = ((NormalizedNodePayload) response.getEntity()).getData();
 317
 318         // config data present
 319         assertTrue(((ContainerNode) data).findChildByArg(buildPlayerCont.getIdentifier()).isPresent());
 320         assertTrue(((ContainerNode) data).findChildByArg(buildLibraryCont.getIdentifier()).isPresent());
 321
 322         // state data absent
 323         assertFalse(((ContainerNode) data).findChildByArg(buildPlaylistList.getIdentifier()).isPresent());
 324     }
 325
 326     /**
 327      * Read data from operational datastore according to content parameter.
 328      */
 329     @Test
 330     public void testReadDataOperationalTest() {
 331         final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
 332         parameters.put("content", List.of("nonconfig"));
 333
 334         doReturn(parameters).when(uriInfo).getQueryParameters();
 335         doReturn(immediateFluentFuture(Optional.of(buildBaseContOperational))).when(read)
 336                 .read(LogicalDatastoreType.OPERATIONAL, iidBase);
 337
 338         final Response response = dataService.readData("example-jukebox:jukebox", uriInfo);
 339
 340         assertNotNull(response);
 341         assertEquals(200, response.getStatus());
 342
 343         // response must contain only operational data
 344         final NormalizedNode data = ((NormalizedNodePayload) response.getEntity()).getData();
 345
 346         // state data present
 347         assertTrue(((ContainerNode) data).findChildByArg(buildPlayerCont.getIdentifier()).isPresent());
 348         assertTrue(((ContainerNode) data).findChildByArg(buildPlaylistList.getIdentifier()).isPresent());
 349
 350         // config data absent
 351         assertFalse(((ContainerNode) data).findChildByArg(buildLibraryCont.getIdentifier()).isPresent());
 352     }
 353
 354     @Test
 355     public void testPutData() {
 356         final InstanceIdentifierContext iidContext = InstanceIdentifierContext.ofLocalPath(contextRef, iidBase);
 357         final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseCont);
 358
 359         doReturn(immediateTrueFluentFuture()).when(read)
 360                 .exists(LogicalDatastoreType.CONFIGURATION, iidBase);
 361         doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, iidBase, payload.getData());
 362         final Response response = dataService.putData(null, payload, uriInfo);
 363         assertNotNull(response);
 364         assertEquals(Response.Status.NO_CONTENT.getStatusCode(), response.getStatus());
 365     }
 366
 367     @Test
 368     public void testPutDataWithMountPoint() {
 369         final InstanceIdentifierContext iidContext =
 370             InstanceIdentifierContext.ofMountPointPath(mountPoint, contextRef, iidBase);
 371         final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseCont);
 372
 373         doReturn(immediateTrueFluentFuture()).when(read)
 374                 .exists(LogicalDatastoreType.CONFIGURATION, iidBase);
 375         doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, iidBase, payload.getData());
 376         final Response response = dataService.putData(null, payload, uriInfo);
 377         assertNotNull(response);
 378         assertEquals(Response.Status.NO_CONTENT.getStatusCode(), response.getStatus());
 379     }
 380
 381     @Test
 382     public void testPostData() {
 383         final QName listQname = QName.create(baseQName, "playlist");
 384         final QName listKeyQname = QName.create(baseQName, "name");
 385         final NodeIdentifierWithPredicates nodeWithKey =
 386                 NodeIdentifierWithPredicates.of(listQname, listKeyQname, "name of band");
 387
 388         doReturn(new MultivaluedHashMap<String, String>()).when(uriInfo).getQueryParameters();
 389         final InstanceIdentifierContext iidContext = InstanceIdentifierContext.ofLocalPath(contextRef, iidBase);
 390         final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, Builders.mapBuilder()
 391             .withNodeIdentifier(new NodeIdentifier(listQname))
 392             .withChild(Builders.mapEntryBuilder()
 393                 .withNodeIdentifier(nodeWithKey)
 394                 .withChild(ImmutableNodes.leafNode(QName.create(baseQName, "name"), "name of band"))
 395                 .withChild(ImmutableNodes.leafNode(QName.create(baseQName, "description"), "band description"))
 396                 .build())
 397             .build());
 398         final MapNode data = (MapNode) payload.getData();
 399         final MapEntryNode entryNode = data.body().iterator().next();
 400         final NodeIdentifierWithPredicates identifier = entryNode.getIdentifier();
 401         final YangInstanceIdentifier node =
 402                 payload.getInstanceIdentifierContext().getInstanceIdentifier().node(identifier);
 403         doReturn(immediateFalseFluentFuture())
 404                 .when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, node);
 405         doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, node, entryNode);
 406         doReturn(UriBuilder.fromUri("http://localhost:8181/rests/")).when(uriInfo).getBaseUriBuilder();
 407
 408         final Response response = dataService.postData(null, payload, uriInfo);
 409         assertEquals(201, response.getStatus());
 410     }
 411
 412     @Test
 413     public void testDeleteData() {
 414         doNothing().when(readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidBase);
 415         doReturn(immediateTrueFluentFuture())
 416                 .when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidBase);
 417         final Response response = dataService.deleteData("example-jukebox:jukebox");
 418         assertNotNull(response);
 419         assertEquals(Response.Status.NO_CONTENT.getStatusCode(), response.getStatus());
 420     }
 421
 422     /**
 423      * Test of deleting data on mount point.
 424      */
 425     @Test
 426     public void testDeleteDataMountPoint() {
 427         doNothing().when(readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidBase);
 428         doReturn(immediateTrueFluentFuture())
 429                 .when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidBase);
 430         final Response response =
 431                 dataService.deleteData("example-jukebox:jukebox/yang-ext:mount/example-jukebox:jukebox");
 432         assertNotNull(response);
 433         assertEquals(Response.Status.NO_CONTENT.getStatusCode(), response.getStatus());
 434     }
 435
 436     @Test
 437     public void testPatchData() {
 438         final InstanceIdentifierContext iidContext = InstanceIdentifierContext.ofLocalPath(contextRef, iidBase);
 439         final List<PatchEntity> entity = new ArrayList<>();
 440         final YangInstanceIdentifier iidleaf = YangInstanceIdentifier.builder(iidBase)
 441                 .node(containerPlayerQname)
 442                 .node(leafQname)
 443                 .build();
 444         entity.add(new PatchEntity("create data", CREATE, iidBase, buildBaseCont));
 445         entity.add(new PatchEntity("replace data", REPLACE, iidBase, buildBaseCont));
 446         entity.add(new PatchEntity("delete data", DELETE, iidleaf));
 447         final PatchContext patch = new PatchContext(iidContext, entity, "test patch id");
 448
 449         doNothing().when(readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidleaf);
 450         doReturn(immediateFalseFluentFuture())
 451                 .when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidBase);
 452         doReturn(immediateTrueFluentFuture())
 453                 .when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidleaf);
 454         final PatchStatusContext status = dataService.patchData(patch, uriInfo);
 455         assertTrue(status.isOk());
 456         assertEquals(3, status.getEditCollection().size());
 457         assertEquals("replace data", status.getEditCollection().get(1).getEditId());
 458     }
 459
 460     @Test
 461     public void testPatchDataMountPoint() throws Exception {
 462         final InstanceIdentifierContext iidContext = InstanceIdentifierContext.ofMountPointPath(mountPoint, contextRef,
 463                 iidBase);
 464         final List<PatchEntity> entity = new ArrayList<>();
 465         final YangInstanceIdentifier iidleaf = YangInstanceIdentifier.builder(iidBase)
 466                 .node(containerPlayerQname)
 467                 .node(leafQname)
 468                 .build();
 469         entity.add(new PatchEntity("create data", CREATE, iidBase, buildBaseCont));
 470         entity.add(new PatchEntity("replace data", REPLACE, iidBase, buildBaseCont));
 471         entity.add(new PatchEntity("delete data", DELETE, iidleaf));
 472         final PatchContext patch = new PatchContext(iidContext, entity, "test patch id");
 473
 474         doNothing().when(readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidleaf);
 475         doReturn(immediateFalseFluentFuture())
 476                 .when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidBase);
 477         doReturn(immediateTrueFluentFuture()).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidleaf);
 478
 479         final PatchStatusContext status = dataService.patchData(patch, uriInfo);
 480         assertTrue(status.isOk());
 481         assertEquals(3, status.getEditCollection().size());
 482         assertNull(status.getGlobalErrors());
 483     }
 484
 485     @Test
 486     public void testPatchDataDeleteNotExist() {
 487         final InstanceIdentifierContext iidContext = InstanceIdentifierContext.ofLocalPath(contextRef, iidBase);
 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 }