2 * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
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
9 package org.opendaylight.restconf.restful.services.impl;
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;
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;
69 public class RestconfDataServiceImplTest {
71 private static final String PATH_FOR_NEW_SCHEMA_CONTEXT = "/jukebox";
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;
88 private TransactionChainHandler transactionChainHandler;
90 private DOMTransactionChain domTransactionChain;
92 private UriInfo uriInfo;
94 private DOMDataReadWriteTransaction readWrite;
96 private DOMDataReadOnlyTransaction read;
98 private DOMDataWriteTransaction write;
100 private DOMMountPointServiceHandler mountPointServiceHandler;
102 private DOMMountPointService mountPointService;
104 private DOMMountPoint mountPoint;
106 private DOMDataBroker mountDataBroker;
108 private DOMTransactionChain transactionChain;
111 public void setUp() throws Exception {
112 MockitoAnnotations.initMocks(this);
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");
118 final QName containerLibraryQName = QName.create(baseQName, "library");
119 final QName listPlaylistQName = QName.create(baseQName, "playlist");
121 final LeafNode buildLeaf = Builders.leafBuilder()
122 .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(leafQname))
126 buildPlayerCont = Builders.containerBuilder()
127 .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(containerPlayerQname))
128 .withChild(buildLeaf)
131 buildLibraryCont = Builders.containerBuilder()
132 .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(containerLibraryQName))
135 buildPlaylistList = Builders.mapBuilder()
136 .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listPlaylistQName))
139 buildBaseCont = Builders.containerBuilder()
140 .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(baseQName))
141 .withChild(buildPlayerCont)
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)
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)
158 iidBase = YangInstanceIdentifier.builder()
162 contextRef = new SchemaContextRef(TestRestconfUtils.loadSchemaContext(PATH_FOR_NEW_SCHEMA_CONTEXT));
163 schemaNode = DataSchemaContextTree.from(contextRef.get()).getChild(iidBase).getDataSchemaNode();
165 final SchemaContextHandler schemaContextHandler = new SchemaContextHandler();
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();
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());
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.
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);
206 final Response response = dataService.readData(
207 "example-jukebox:jukebox/yang-ext:mount/example-jukebox:jukebox", uriInfo);
209 assertNotNull(response);
210 assertEquals(200, response.getStatus());
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());
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,
226 doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(read).read(LogicalDatastoreType.OPERATIONAL,
228 dataService.readData("example-jukebox:jukebox", uriInfo);
232 * Read data from config datastore according to content parameter
235 public void testReadDataConfigTest() {
236 final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
237 parameters.put("content", Collections.singletonList("config"));
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);
245 final Response response = dataService.readData("example-jukebox:jukebox", uriInfo);
247 assertNotNull(response);
248 assertEquals(200, response.getStatus());
250 // response must contain only config data
251 final NormalizedNode<?, ?> data = ((NormalizedNodeContext) response.getEntity()).getData();
253 // config data present
254 assertTrue(((ContainerNode) data).getChild(buildPlayerCont.getIdentifier()).isPresent());
255 assertTrue(((ContainerNode) data).getChild(buildLibraryCont.getIdentifier()).isPresent());
258 assertFalse(((ContainerNode) data).getChild(buildPlaylistList.getIdentifier()).isPresent());
262 * Read data from operational datastore according to content parameter
265 public void testReadDataOperationalTest() {
266 final MultivaluedHashMap<String, String> parameters = new MultivaluedHashMap<>();
267 parameters.put("content", Collections.singletonList("nonconfig"));
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);
275 final Response response = dataService.readData("example-jukebox:jukebox", uriInfo);
277 assertNotNull(response);
278 assertEquals(200, response.getStatus());
280 // response must contain only operational data
281 final NormalizedNode<?, ?> data = ((NormalizedNodeContext) response.getEntity()).getData();
283 // state data present
284 assertTrue(((ContainerNode) data).getChild(buildPlayerCont.getIdentifier()).isPresent());
285 assertTrue(((ContainerNode) data).getChild(buildPlaylistList.getIdentifier()).isPresent());
287 // config data absent
288 assertFalse(((ContainerNode) data).getChild(buildLibraryCont.getIdentifier()).isPresent());
292 public void testPutData() {
293 final InstanceIdentifierContext<DataSchemaNode> iidContext = new InstanceIdentifierContext<>(iidBase, schemaNode, null, contextRef.get());
294 final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, buildBaseCont);
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());
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);
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());
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")
333 final LeafNode<Object> content2 = Builders.leafBuilder()
334 .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create(baseQName, "description")))
335 .withValue("band description")
337 final MapEntryNode mapEntryNode = Builders.mapEntryBuilder()
338 .withNodeIdentifier(nodeWithKey)
342 final MapNode buildList = Builders.mapBuilder()
343 .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listQname))
344 .withChild(mapEntryNode)
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();
359 final Response response = dataService.postData(null, payload, uriInfo);
360 assertEquals(201, response.getStatus());
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());
374 * Test of deleting data on mount point
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());
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)
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");
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());
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)
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");
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);
436 final PATCHStatusContext status = dataService.patchData(patch, uriInfo);
437 assertTrue(status.isOk());
438 assertEquals(3, status.getEditCollection().size());
439 assertNull(status.getGlobalErrors());
443 public void testPatchDataDeleteNotExist() throws Exception {
444 final Field handler = RestConnectorProvider.class.getDeclaredField("transactionChainHandler");
445 final Field broker = RestConnectorProvider.class.getDeclaredField("dataBroker");
447 handler.setAccessible(true);
448 handler.set(RestConnectorProvider.class, mock(TransactionChainHandler.class));
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)
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");
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);
474 handler.set(RestConnectorProvider.class, null);
475 handler.setAccessible(false);
477 broker.set(RestConnectorProvider.class, null);
478 broker.setAccessible(false);
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);