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