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