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