restconf/sal-rest-connector/src/test/java/org/opendaylight/restconf/restful/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
   9 package org.opendaylight.restconf.restful.services.impl;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertFalse;
  13 import static org.junit.Assert.assertNotNull;
  14 import static org.junit.Assert.assertNull;
  15 import static org.junit.Assert.assertTrue;
  16 import static org.mockito.Matchers.any;
  17 import static org.mockito.Mockito.doNothing;
  18 import static org.mockito.Mockito.doReturn;
  19 import static org.mockito.Mockito.mock;
  20
  21 import com.google.common.base.Optional;
  22 import com.google.common.util.concurrent.Futures;
  23 import java.lang.reflect.Field;
  24 import java.util.ArrayList;
  25 import java.util.Collections;
  26 import java.util.List;
  27 import javax.ws.rs.core.MultivaluedHashMap;
  28 import javax.ws.rs.core.Response;
  29 import javax.ws.rs.core.UriBuilder;
  30 import javax.ws.rs.core.UriInfo;
  31 import org.junit.Before;
  32 import org.junit.Test;
  33 import org.mockito.Mock;
  34 import org.mockito.Mockito;
  35 import org.mockito.MockitoAnnotations;
  36 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  37 import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
  38 import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
  39 import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
  40 import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
  41 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
  42 import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
  43 import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
  44 import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
  45 import org.opendaylight.controller.md.sal.rest.common.TestRestconfUtils;
  46 import org.opendaylight.netconf.sal.restconf.impl.InstanceIdentifierContext;
  47 import org.opendaylight.netconf.sal.restconf.impl.NormalizedNodeContext;
  48 import org.opendaylight.netconf.sal.restconf.impl.PATCHContext;
  49 import org.opendaylight.netconf.sal.restconf.impl.PATCHEntity;
  50 import org.opendaylight.netconf.sal.restconf.impl.PATCHStatusContext;
  51 import org.opendaylight.netconf.sal.restconf.impl.RestconfDocumentedException;
  52 import org.opendaylight.restconf.RestConnectorProvider;
  53 import org.opendaylight.restconf.common.references.SchemaContextRef;
  54 import org.opendaylight.restconf.handlers.DOMMountPointServiceHandler;
  55 import org.opendaylight.restconf.handlers.SchemaContextHandler;
  56 import org.opendaylight.restconf.handlers.TransactionChainHandler;
  57 import org.opendaylight.yangtools.yang.common.QName;
  58 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  59 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  60 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
  61 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
  62 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
  63 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  64 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  65 import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
  66 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  67 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
  68
  69 public class RestconfDataServiceImplTest {
  70
  71     private static final String PATH_FOR_NEW_SCHEMA_CONTEXT = "/jukebox";
  72
  73     private ContainerNode buildBaseCont;
  74     private ContainerNode buildBaseContConfig;
  75     private ContainerNode buildBaseContOperational;
  76     private SchemaContextRef contextRef;
  77     private YangInstanceIdentifier iidBase;
  78     private DataSchemaNode schemaNode;
  79     private RestconfDataServiceImpl dataService;
  80     private QName baseQName;
  81     private QName containerPlayerQname;
  82     private QName leafQname;
  83     private ContainerNode buildPlayerCont;
  84     private ContainerNode buildLibraryCont;
  85     private MapNode buildPlaylistList;
  86
  87     @Mock
  88     private TransactionChainHandler transactionChainHandler;
  89     @Mock
  90     private DOMTransactionChain domTransactionChain;
  91     @Mock
  92     private UriInfo uriInfo;
  93     @Mock
  94     private DOMDataReadWriteTransaction readWrite;
  95     @Mock
  96     private DOMDataReadOnlyTransaction read;
  97     @Mock
  98     private DOMDataWriteTransaction write;
  99     @Mock
 100     private DOMMountPointServiceHandler mountPointServiceHandler;
 101     @Mock
 102     private DOMMountPointService mountPointService;
 103     @Mock
 104     private DOMMountPoint mountPoint;
 105     @Mock
 106     private DOMDataBroker mountDataBroker;
 107     @Mock
 108     private DOMTransactionChain transactionChain;
 109
 110     @Before
 111     public void setUp() throws Exception {
 112         MockitoAnnotations.initMocks(this);
 113
 114         baseQName = QName.create("http://example.com/ns/example-jukebox", "2015-04-04", "jukebox");
 115         containerPlayerQname = QName.create(baseQName, "player");
 116         leafQname = QName.create(baseQName, "gap");
 117
 118         final QName containerLibraryQName = QName.create(baseQName, "library");
 119         final QName listPlaylistQName = QName.create(baseQName, "playlist");
 120
 121         final LeafNode buildLeaf = Builders.leafBuilder()
 122                 .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(leafQname))
 123                 .withValue(0.2)
 124                 .build();
 125
 126         buildPlayerCont = Builders.containerBuilder()
 127                 .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(containerPlayerQname))
 128                 .withChild(buildLeaf)
 129                 .build();
 130
 131         buildLibraryCont = Builders.containerBuilder()
 132                 .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(containerLibraryQName))
 133                 .build();
 134
 135         buildPlaylistList = Builders.mapBuilder()
 136                 .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listPlaylistQName))
 137                 .build();
 138
 139         buildBaseCont = Builders.containerBuilder()
 140                 .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(baseQName))
 141                 .withChild(buildPlayerCont)
 142                 .build();
 143
 144         // config contains one child the same as in operational and one additional
 145         buildBaseContConfig = Builders.containerBuilder()
 146                 .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(baseQName))
 147                 .withChild(buildPlayerCont)
 148                 .withChild(buildLibraryCont)
 149                 .build();
 150
 151         // operational contains one child the same as in config and one additional
 152         buildBaseContOperational = Builders.containerBuilder()
 153                 .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(baseQName))
 154                 .withChild(buildPlayerCont)
 155                 .withChild(buildPlaylistList)
 156                 .build();
 157
 158         iidBase = YangInstanceIdentifier.builder()
 159                 .node(baseQName)
 160                 .build();
 161
 162         contextRef = new SchemaContextRef(TestRestconfUtils.loadSchemaContext(PATH_FOR_NEW_SCHEMA_CONTEXT));
 163         schemaNode = DataSchemaContextTree.from(contextRef.get()).getChild(iidBase).getDataSchemaNode();
 164
 165         final SchemaContextHandler schemaContextHandler = new SchemaContextHandler();
 166
 167         schemaContextHandler.onGlobalContextUpdated(contextRef.get());
 168         dataService = new RestconfDataServiceImpl(schemaContextHandler, transactionChainHandler, mountPointServiceHandler);
 169         doReturn(domTransactionChain).when(transactionChainHandler).get();
 170         doReturn(read).when(domTransactionChain).newReadOnlyTransaction();
 171         doReturn(readWrite).when(domTransactionChain).newReadWriteTransaction();
 172         doReturn(write).when(domTransactionChain).newWriteOnlyTransaction();
 173         doReturn(mountPointService).when(mountPointServiceHandler).get();
 174         doReturn(Optional.of(mountPoint)).when(mountPointService).getMountPoint(any(YangInstanceIdentifier.class));
 175         doReturn(contextRef.get()).when(mountPoint).getSchemaContext();
 176         doReturn(Optional.of(mountDataBroker)).when(mountPoint).getService(DOMDataBroker.class);
 177         doReturn(transactionChain).when(mountDataBroker).createTransactionChain(any(TransactionChainListener.class));
 178         doReturn(read).when(transactionChain).newReadOnlyTransaction();
 179         doReturn(readWrite).when(transactionChain).newReadWriteTransaction();
 180     }
 181
 182     @Test
 183     public void testReadData() {
 184         doReturn(new MultivaluedHashMap<String, String>()).when(uriInfo).getQueryParameters();
 185         doReturn(Futures.immediateCheckedFuture(Optional.of(buildBaseCont))).when(read)
 186                 .read(LogicalDatastoreType.CONFIGURATION, iidBase);
 187         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(read).read(LogicalDatastoreType.OPERATIONAL, iidBase);
 188         final Response response = dataService.readData("example-jukebox:jukebox", uriInfo);
 189         assertNotNull(response);
 190         assertEquals(200, response.getStatus());
 191         assertEquals(buildBaseCont, ((NormalizedNodeContext) response.getEntity()).getData());
 192     }
 193
 194     /**
 195      * Test read data from mount point when both {@link LogicalDatastoreType#CONFIGURATION} and
 196      * {@link LogicalDatastoreType#OPERATIONAL} contains the same data and some additional data to be merged.
 197      */
 198     @Test
 199     public void testReadDataMountPoint() {
 200         doReturn(new MultivaluedHashMap<String, String>()).when(uriInfo).getQueryParameters();
 201         doReturn(Futures.immediateCheckedFuture(Optional.of(buildBaseContConfig))).when(read)
 202                 .read(LogicalDatastoreType.CONFIGURATION, iidBase);
 203         doReturn(Futures.immediateCheckedFuture(Optional.of(buildBaseContOperational))).when(read)
 204                 .read(LogicalDatastoreType.OPERATIONAL, iidBase);
 205
 206         final Response response = dataService.readData(
 207                 "example-jukebox:jukebox/yang-ext:mount/example-jukebox:jukebox", uriInfo);
 208
 209         assertNotNull(response);
 210         assertEquals(200, response.getStatus());
 211
 212         // response must contain all child nodes from config and operational containers merged in one container
 213         final NormalizedNode<?, ?> data = ((NormalizedNodeContext) response.getEntity()).getData();
 214         assertTrue(data instanceof ContainerNode);
 215         assertEquals(3, ((ContainerNode) data).getValue().size());
 216         assertTrue(((ContainerNode) data).getChild(buildPlayerCont.getIdentifier()).isPresent());
 217         assertTrue(((ContainerNode) data).getChild(buildLibraryCont.getIdentifier()).isPresent());
 218         assertTrue(((ContainerNode) data).getChild(buildPlaylistList.getIdentifier()).isPresent());
 219     }
 220
 221     @Test(expected = RestconfDocumentedException.class)
 222     public void testReadDataNoData() {
 223         doReturn(new MultivaluedHashMap<String, String>()).when(uriInfo).getQueryParameters();
 224         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(read).read(LogicalDatastoreType.CONFIGURATION,
 225                 iidBase);
 226         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(read).read(LogicalDatastoreType.OPERATIONAL,
 227                 iidBase);
 228         dataService.readData("example-jukebox:jukebox", uriInfo);
 229     }
 230
 231     /**
 232      * Read data from config datastore according to content parameter
 233      */
 234     @Test
 235     public void testReadDataConfigTest() {
 236         final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
 237         parameters.put("content", Collections.singletonList("config"));
 238
 239         doReturn(parameters).when(uriInfo).getQueryParameters();
 240         doReturn(Futures.immediateCheckedFuture(Optional.of(buildBaseContConfig))).when(read)
 241                 .read(LogicalDatastoreType.CONFIGURATION, iidBase);
 242         doReturn(Futures.immediateCheckedFuture(Optional.of(buildBaseContOperational))).when(read)
 243                 .read(LogicalDatastoreType.OPERATIONAL, iidBase);
 244
 245         final Response response = dataService.readData("example-jukebox:jukebox", uriInfo);
 246
 247         assertNotNull(response);
 248         assertEquals(200, response.getStatus());
 249
 250         // response must contain only config data
 251         final NormalizedNode<?, ?> data = ((NormalizedNodeContext) response.getEntity()).getData();
 252
 253         // config data present
 254         assertTrue(((ContainerNode) data).getChild(buildPlayerCont.getIdentifier()).isPresent());
 255         assertTrue(((ContainerNode) data).getChild(buildLibraryCont.getIdentifier()).isPresent());
 256
 257         // state data absent
 258         assertFalse(((ContainerNode) data).getChild(buildPlaylistList.getIdentifier()).isPresent());
 259     }
 260
 261     /**
 262      * Read data from operational datastore according to content parameter
 263      */
 264     @Test
 265     public void testReadDataOperationalTest() {
 266         final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
 267         parameters.put("content", Collections.singletonList("nonconfig"));
 268
 269         doReturn(parameters).when(uriInfo).getQueryParameters();
 270         doReturn(Futures.immediateCheckedFuture(Optional.of(buildBaseContConfig))).when(read)
 271                 .read(LogicalDatastoreType.CONFIGURATION, iidBase);
 272         doReturn(Futures.immediateCheckedFuture(Optional.of(buildBaseContOperational))).when(read)
 273                 .read(LogicalDatastoreType.OPERATIONAL, iidBase);
 274
 275         final Response response = dataService.readData("example-jukebox:jukebox", uriInfo);
 276
 277         assertNotNull(response);
 278         assertEquals(200, response.getStatus());
 279
 280         // response must contain only operational data
 281         final NormalizedNode<?, ?> data = ((NormalizedNodeContext) response.getEntity()).getData();
 282
 283         // state data present
 284         assertTrue(((ContainerNode) data).getChild(buildPlayerCont.getIdentifier()).isPresent());
 285         assertTrue(((ContainerNode) data).getChild(buildPlaylistList.getIdentifier()).isPresent());
 286
 287         // config data absent
 288         assertFalse(((ContainerNode) data).getChild(buildLibraryCont.getIdentifier()).isPresent());
 289     }
 290
 291     @Test
 292     public void testPutData() {
 293         final InstanceIdentifierContext<DataSchemaNode> iidContext = new InstanceIdentifierContext<>(iidBase, schemaNode, null, contextRef.get());
 294         final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, buildBaseCont);
 295
 296         doReturn(Futures.immediateCheckedFuture(Optional.of(buildBaseCont))).when(read)
 297                 .read(LogicalDatastoreType.CONFIGURATION, iidBase);
 298         doNothing().when(write).put(LogicalDatastoreType.CONFIGURATION, iidBase, payload.getData());
 299         doReturn(Futures.immediateCheckedFuture(null)).when(write).submit();
 300         final Response response = dataService.putData(null, payload);
 301         assertNotNull(response);
 302         assertEquals(200, response.getStatus());
 303     }
 304
 305     @Test
 306     public void testPutDataWithMountPoint() {
 307         final DOMDataBroker dataBroker = Mockito.mock(DOMDataBroker.class);
 308         final DOMMountPoint mountPoint = Mockito.mock(DOMMountPoint.class);
 309         doReturn(Optional.of(dataBroker)).when(mountPoint).getService(DOMDataBroker.class);
 310         doReturn(transactionChainHandler.get()).when(dataBroker).createTransactionChain(RestConnectorProvider.transactionListener);
 311         final InstanceIdentifierContext<DataSchemaNode> iidContext = new InstanceIdentifierContext<>(iidBase, schemaNode, mountPoint, contextRef.get());
 312         final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, buildBaseCont);
 313
 314         doReturn(Futures.immediateCheckedFuture(Optional.of(buildBaseCont))).when(read)
 315                 .read(LogicalDatastoreType.CONFIGURATION, iidBase);
 316         doNothing().when(write).put(LogicalDatastoreType.CONFIGURATION, iidBase, payload.getData());
 317         doReturn(Futures.immediateCheckedFuture(null)).when(write).submit();
 318         final Response response = dataService.putData(null, payload);
 319         assertNotNull(response);
 320         assertEquals(200, response.getStatus());
 321     }
 322
 323     @Test
 324     public void testPostData() {
 325         final QName listQname = QName.create(baseQName, "playlist");
 326         final QName listKeyQname = QName.create(baseQName, "name");
 327         final YangInstanceIdentifier.NodeIdentifierWithPredicates nodeWithKey =
 328                 new YangInstanceIdentifier.NodeIdentifierWithPredicates(listQname, listKeyQname, "name of band");
 329         final LeafNode<Object> content = Builders.leafBuilder()
 330                 .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create(baseQName, "name")))
 331                 .withValue("name of band")
 332                 .build();
 333         final LeafNode<Object> content2 = Builders.leafBuilder()
 334                 .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create(baseQName, "description")))
 335                 .withValue("band description")
 336                 .build();
 337         final MapEntryNode mapEntryNode = Builders.mapEntryBuilder()
 338                 .withNodeIdentifier(nodeWithKey)
 339                 .withChild(content)
 340                 .withChild(content2)
 341                 .build();
 342         final MapNode buildList = Builders.mapBuilder()
 343                 .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listQname))
 344                 .withChild(mapEntryNode)
 345                 .build();
 346
 347         doReturn(new MultivaluedHashMap<String, String>()).when(uriInfo).getQueryParameters();
 348         final InstanceIdentifierContext<? extends SchemaNode> iidContext = new InstanceIdentifierContext<>(iidBase, null, null, contextRef.get());
 349         final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, buildList);
 350         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(read).read(LogicalDatastoreType.CONFIGURATION, iidBase);
 351         final MapNode data = (MapNode) payload.getData();
 352         final YangInstanceIdentifier.NodeIdentifierWithPredicates identifier = data.getValue().iterator().next().getIdentifier();
 353         final YangInstanceIdentifier node = payload.getInstanceIdentifierContext().getInstanceIdentifier().node(identifier);
 354         doReturn(Futures.immediateCheckedFuture(false)).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, node);
 355         doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, node, payload.getData());
 356         doReturn(Futures.immediateCheckedFuture(null)).when(readWrite).submit();
 357         doReturn(UriBuilder.fromUri("http://localhost:8181/restconf/15/")).when(uriInfo).getBaseUriBuilder();
 358
 359         final Response response = dataService.postData(null, payload, uriInfo);
 360         assertEquals(201, response.getStatus());
 361     }
 362
 363     @Test
 364     public void testDeleteData() {
 365         doNothing().when(readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidBase);
 366         doReturn(Futures.immediateCheckedFuture(null)).when(readWrite).submit();
 367         doReturn(Futures.immediateCheckedFuture(true)).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidBase);
 368         final Response response = dataService.deleteData("example-jukebox:jukebox");
 369         assertNotNull(response);
 370         assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
 371     }
 372
 373     /**
 374      * Test of deleting data on mount point
 375      */
 376     @Test
 377     public void testDeleteDataMountPoint() {
 378         doNothing().when(readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidBase);
 379         doReturn(Futures.immediateCheckedFuture(null)).when(readWrite).submit();
 380         doReturn(Futures.immediateCheckedFuture(true)).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidBase);
 381         final Response response = dataService.deleteData("example-jukebox:jukebox/yang-ext:mount/example-jukebox:jukebox");
 382         assertNotNull(response);
 383         assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
 384     }
 385
 386     @Test
 387     public void testPatchData() throws Exception {
 388         final InstanceIdentifierContext<? extends SchemaNode> iidContext = new InstanceIdentifierContext<>(iidBase, schemaNode, null, contextRef.get());
 389         final List<PATCHEntity> entity = new ArrayList<>();
 390         final YangInstanceIdentifier iidleaf = YangInstanceIdentifier.builder(iidBase)
 391                 .node(containerPlayerQname)
 392                 .node(leafQname)
 393                 .build();
 394         entity.add(new PATCHEntity("create data", "CREATE", iidBase, buildBaseCont));
 395         entity.add(new PATCHEntity("replace data", "REPLACE", iidBase, buildBaseCont));
 396         entity.add(new PATCHEntity("delete data", "DELETE", iidleaf));
 397         final PATCHContext patch = new PATCHContext(iidContext, entity, "test patch id");
 398
 399         doReturn(Futures.immediateCheckedFuture(Optional.of(buildBaseCont))).when(read)
 400                 .read(LogicalDatastoreType.CONFIGURATION, iidBase);
 401         doNothing().when(write).put(LogicalDatastoreType.CONFIGURATION, iidBase, buildBaseCont);
 402         doReturn(Futures.immediateCheckedFuture(null)).when(write).submit();
 403         doNothing().when(readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidleaf);
 404         doReturn(Futures.immediateCheckedFuture(null)).when(readWrite).submit();
 405         doReturn(Futures.immediateCheckedFuture(false)).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidBase);
 406         doReturn(Futures.immediateCheckedFuture(true)).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidleaf);
 407         final PATCHStatusContext status = dataService.patchData(patch, uriInfo);
 408         assertTrue(status.isOk());
 409         assertEquals(3, status.getEditCollection().size());
 410         assertEquals("replace data", status.getEditCollection().get(1).getEditId());
 411     }
 412
 413     @Test
 414     public void testPatchDataMountPoint() throws Exception {
 415         final InstanceIdentifierContext<? extends SchemaNode> iidContext = new InstanceIdentifierContext<>(
 416                 iidBase, schemaNode, mountPoint, contextRef.get());
 417         final List<PATCHEntity> entity = new ArrayList<>();
 418         final YangInstanceIdentifier iidleaf = YangInstanceIdentifier.builder(iidBase)
 419                 .node(containerPlayerQname)
 420                 .node(leafQname)
 421                 .build();
 422         entity.add(new PATCHEntity("create data", "CREATE", iidBase, buildBaseCont));
 423         entity.add(new PATCHEntity("replace data", "REPLACE", iidBase, buildBaseCont));
 424         entity.add(new PATCHEntity("delete data", "DELETE", iidleaf));
 425         final PATCHContext patch = new PATCHContext(iidContext, entity, "test patch id");
 426
 427         doReturn(Futures.immediateCheckedFuture(Optional.of(buildBaseCont))).when(read)
 428                 .read(LogicalDatastoreType.CONFIGURATION, iidBase);
 429         doNothing().when(write).put(LogicalDatastoreType.CONFIGURATION, iidBase, buildBaseCont);
 430         doReturn(Futures.immediateCheckedFuture(null)).when(write).submit();
 431         doNothing().when(readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidleaf);
 432         doReturn(Futures.immediateCheckedFuture(null)).when(readWrite).submit();
 433         doReturn(Futures.immediateCheckedFuture(false)).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidBase);
 434         doReturn(Futures.immediateCheckedFuture(true)).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidleaf);
 435
 436         final PATCHStatusContext status = dataService.patchData(patch, uriInfo);
 437         assertTrue(status.isOk());
 438         assertEquals(3, status.getEditCollection().size());
 439         assertNull(status.getGlobalErrors());
 440     }
 441
 442     @Test
 443     public void testPatchDataDeleteNotExist() throws Exception {
 444         final Field handler = RestConnectorProvider.class.getDeclaredField("transactionChainHandler");
 445         final Field broker = RestConnectorProvider.class.getDeclaredField("dataBroker");
 446
 447         handler.setAccessible(true);
 448         handler.set(RestConnectorProvider.class, mock(TransactionChainHandler.class));
 449
 450         broker.setAccessible(true);
 451         broker.set(RestConnectorProvider.class, mock(DOMDataBroker.class));
 452         final InstanceIdentifierContext<? extends SchemaNode> iidContext = new InstanceIdentifierContext<>(iidBase, schemaNode, null, contextRef.get());
 453         final List<PATCHEntity> entity = new ArrayList<>();
 454         final YangInstanceIdentifier iidleaf = YangInstanceIdentifier.builder(iidBase)
 455                 .node(containerPlayerQname)
 456                 .node(leafQname)
 457                 .build();
 458         entity.add(new PATCHEntity("create data", "CREATE", iidBase, buildBaseCont));
 459         entity.add(new PATCHEntity("remove data", "REMOVE", iidleaf));
 460         entity.add(new PATCHEntity("delete data", "DELETE", iidleaf));
 461         final PATCHContext patch = new PATCHContext(iidContext, entity, "test patch id");
 462
 463         doReturn(Futures.immediateCheckedFuture(Optional.of(buildBaseCont))).when(read)
 464                 .read(LogicalDatastoreType.CONFIGURATION, iidBase);
 465         doNothing().when(write).put(LogicalDatastoreType.CONFIGURATION, iidBase, buildBaseCont);
 466         doReturn(Futures.immediateCheckedFuture(null)).when(write).submit();
 467         doNothing().when(readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidleaf);
 468         doReturn(Futures.immediateCheckedFuture(null)).when(readWrite).submit();
 469         doReturn(Futures.immediateCheckedFuture(false)).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidBase);
 470         doReturn(Futures.immediateCheckedFuture(false)).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidleaf);
 471         doReturn(true).when(readWrite).cancel();
 472         final PATCHStatusContext status = dataService.patchData(patch, uriInfo);
 473
 474         handler.set(RestConnectorProvider.class, null);
 475         handler.setAccessible(false);
 476
 477         broker.set(RestConnectorProvider.class, null);
 478         broker.setAccessible(false);
 479
 480         assertFalse(status.isOk());
 481         assertEquals(3, status.getEditCollection().size());
 482         assertTrue(status.getEditCollection().get(0).isOk());
 483         assertTrue(status.getEditCollection().get(1).isOk());
 484         assertFalse(status.getEditCollection().get(2).isOk());
 485         assertFalse(status.getEditCollection().get(2).getEditErrors().isEmpty());
 486         final String errorMessage = status.getEditCollection().get(2).getEditErrors().get(0).getErrorMessage();
 487         assertEquals("Data does not exist", errorMessage);
 488     }
 489 }