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