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