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