restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/PutDataTransactionUtilTest.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 package org.opendaylight.restconf.nb.rfc8040.rests.utils;
   9
  10 import static org.mockito.Mockito.doNothing;
  11 import static org.mockito.Mockito.doReturn;
  12 import static org.mockito.Mockito.mock;
  13 import static org.mockito.Mockito.verify;
  14 import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFalseFluentFuture;
  15 import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFluentFuture;
  16
  17 import java.util.Optional;
  18 import org.junit.Before;
  19 import org.junit.Test;
  20 import org.junit.runner.RunWith;
  21 import org.mockito.Mock;
  22 import org.mockito.Mockito;
  23 import org.mockito.junit.MockitoJUnitRunner;
  24 import org.opendaylight.mdsal.common.api.CommitInfo;
  25 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  26 import org.opendaylight.mdsal.dom.api.DOMDataBroker;
  27 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
  28 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
  29 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
  30 import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
  31 import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
  32 import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
  33 import org.opendaylight.restconf.common.context.NormalizedNodeContext;
  34 import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
  35 import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils;
  36 import org.opendaylight.restconf.nb.rfc8040.handlers.TransactionChainHandler;
  37 import org.opendaylight.restconf.nb.rfc8040.rests.transactions.MdsalRestconfStrategy;
  38 import org.opendaylight.restconf.nb.rfc8040.rests.transactions.NetconfRestconfStrategy;
  39 import org.opendaylight.yangtools.yang.common.QName;
  40 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  41 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  42 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  43 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  44 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
  45 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
  46 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
  47 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  48 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  49 import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
  50 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  51 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
  52 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
  53
  54 @RunWith(MockitoJUnitRunner.StrictStubs.class)
  55 public class PutDataTransactionUtilTest {
  56     private static final String PATH_FOR_NEW_SCHEMA_CONTEXT = "/jukebox";
  57     @Mock
  58     private DOMTransactionChain transactionChain;
  59     @Mock
  60     private DOMDataTreeReadWriteTransaction readWrite;
  61     @Mock
  62     private DOMDataTreeReadTransaction read;
  63     @Mock
  64     private DOMDataTreeWriteTransaction write;
  65     @Mock
  66     private DOMDataBroker mockDataBroker;
  67     @Mock
  68     private NetconfDataTreeService netconfService;
  69
  70     private TransactionChainHandler transactionChainHandler;
  71     private LeafNode<?> buildLeaf;
  72     private ContainerNode buildBaseCont;
  73     private ContainerNode buildBaseContWithList;
  74     private MapEntryNode buildListEntry;
  75     private EffectiveModelContext schema;
  76     private DataSchemaNode schemaNode;
  77     private YangInstanceIdentifier iid;
  78     private DataSchemaNode schemaNode2;
  79     private YangInstanceIdentifier iid2;
  80     private DataSchemaNode schemaNode3;
  81     private YangInstanceIdentifier iid3;
  82
  83     @Before
  84     public void setUp() throws Exception {
  85         this.schema =
  86                 YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles(PATH_FOR_NEW_SCHEMA_CONTEXT));
  87
  88         final QName baseQName = QName.create("http://example.com/ns/example-jukebox", "2015-04-04", "jukebox");
  89         final QName containerQname = QName.create(baseQName, "player");
  90         final QName leafQname = QName.create(baseQName, "gap");
  91         final QName listQname = QName.create(baseQName, "playlist");
  92         final QName listKeyQname = QName.create(baseQName, "name");
  93
  94         final NodeIdentifierWithPredicates nodeWithKey =
  95                 NodeIdentifierWithPredicates.of(listQname, listKeyQname, "name of band");
  96         final NodeIdentifierWithPredicates nodeWithKey2 =
  97                 NodeIdentifierWithPredicates.of(listQname, listKeyQname, "name of band 2");
  98
  99         final DataSchemaContextTree tree = DataSchemaContextTree.from(this.schema);
 100         this.iid = YangInstanceIdentifier.builder()
 101                 .node(baseQName)
 102                 .node(containerQname)
 103                 .node(leafQname)
 104                 .build();
 105         this.schemaNode = tree.findChild(this.iid).orElseThrow().getDataSchemaNode();
 106
 107         this.iid2 = YangInstanceIdentifier.builder()
 108                 .node(baseQName)
 109                 .build();
 110         this.schemaNode2 = tree.findChild(this.iid2).orElseThrow().getDataSchemaNode();
 111
 112         this.iid3 = YangInstanceIdentifier.builder()
 113                 .node(baseQName)
 114                 .node(listQname)
 115                 .node(nodeWithKey)
 116                 .build();
 117         this.schemaNode3 = tree.findChild(this.iid3).orElseThrow().getDataSchemaNode();
 118
 119         this.buildLeaf = Builders.leafBuilder()
 120                 .withNodeIdentifier(new NodeIdentifier(leafQname))
 121                 .withValue(0.2)
 122                 .build();
 123         final ContainerNode buildPlayerCont = Builders.containerBuilder()
 124                 .withNodeIdentifier(new NodeIdentifier(containerQname))
 125                 .withChild(this.buildLeaf)
 126                 .build();
 127         this.buildBaseCont = Builders.containerBuilder()
 128                 .withNodeIdentifier(new NodeIdentifier(baseQName))
 129                 .withChild(buildPlayerCont)
 130                 .build();
 131         final LeafNode<Object> content = Builders.leafBuilder()
 132                 .withNodeIdentifier(new NodeIdentifier(QName.create(baseQName, "name")))
 133                 .withValue("name of band")
 134                 .build();
 135         final LeafNode<Object> content2 = Builders.leafBuilder()
 136                 .withNodeIdentifier(new NodeIdentifier(QName.create(baseQName, "description")))
 137                 .withValue("band description")
 138                 .build();
 139         this.buildListEntry = Builders.mapEntryBuilder()
 140                 .withNodeIdentifier(nodeWithKey)
 141                 .withChild(content)
 142                 .withChild(content2)
 143                 .build();
 144         final LeafNode<Object> content3 = Builders.leafBuilder()
 145                 .withNodeIdentifier(new NodeIdentifier(QName.create(baseQName, "name")))
 146                 .withValue("name of band 2")
 147                 .build();
 148         final LeafNode<Object> content4 = Builders.leafBuilder()
 149                 .withNodeIdentifier(new NodeIdentifier(QName.create(baseQName, "description")))
 150                 .withValue("band description 2")
 151                 .build();
 152         final MapEntryNode buildListEntry2 = Builders.mapEntryBuilder()
 153                 .withNodeIdentifier(nodeWithKey2)
 154                 .withChild(content3)
 155                 .withChild(content4)
 156                 .build();
 157         final MapNode buildList = Builders.mapBuilder()
 158                 .withNodeIdentifier(new NodeIdentifier(listQname))
 159                 .withChild(this.buildListEntry)
 160                 .withChild(buildListEntry2)
 161                 .build();
 162         this.buildBaseContWithList = Builders.containerBuilder()
 163                 .withNodeIdentifier(new NodeIdentifier(baseQName))
 164                 .withChild(buildList)
 165                 .build();
 166
 167         Mockito.doReturn(transactionChain).when(mockDataBroker).createTransactionChain(Mockito.any());
 168         transactionChainHandler = new TransactionChainHandler(mockDataBroker);
 169     }
 170
 171     @Test
 172     public void testValidInputData() {
 173         final InstanceIdentifierContext<DataSchemaNode> iidContext =
 174                 new InstanceIdentifierContext<>(this.iid, this.schemaNode, null, this.schema);
 175         final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildLeaf);
 176         PutDataTransactionUtil.validInputData(iidContext.getSchemaNode(), payload);
 177     }
 178
 179     @Test
 180     public void testValidTopLevelNodeName() {
 181         InstanceIdentifierContext<DataSchemaNode> iidContext =
 182                 new InstanceIdentifierContext<>(this.iid, this.schemaNode, null, this.schema);
 183         NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildLeaf);
 184         PutDataTransactionUtil.validTopLevelNodeName(iidContext.getInstanceIdentifier(), payload);
 185
 186         iidContext = new InstanceIdentifierContext<>(this.iid2, this.schemaNode2, null, this.schema);
 187         payload = new NormalizedNodeContext(iidContext, this.buildBaseCont);
 188         PutDataTransactionUtil.validTopLevelNodeName(iidContext.getInstanceIdentifier(), payload);
 189     }
 190
 191     @Test(expected = RestconfDocumentedException.class)
 192     public void testValidTopLevelNodeNamePathEmpty() {
 193         final InstanceIdentifierContext<DataSchemaNode> iidContext =
 194                 new InstanceIdentifierContext<>(this.iid, this.schemaNode, null, this.schema);
 195         final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildLeaf);
 196         PutDataTransactionUtil.validTopLevelNodeName(YangInstanceIdentifier.empty(), payload);
 197     }
 198
 199     @Test(expected = RestconfDocumentedException.class)
 200     public void testValidTopLevelNodeNameWrongTopIdentifier() {
 201         final InstanceIdentifierContext<DataSchemaNode> iidContext =
 202                 new InstanceIdentifierContext<>(this.iid, this.schemaNode, null, this.schema);
 203         final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildLeaf);
 204         PutDataTransactionUtil.validTopLevelNodeName(this.iid.getAncestor(1), payload);
 205     }
 206
 207     @Test
 208     public void testValidateListKeysEqualityInPayloadAndUri() {
 209         final InstanceIdentifierContext<DataSchemaNode> iidContext =
 210                 new InstanceIdentifierContext<>(this.iid3, this.schemaNode3, null, this.schema);
 211         final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildListEntry);
 212         PutDataTransactionUtil.validateListKeysEqualityInPayloadAndUri(payload);
 213     }
 214
 215     @Test
 216     public void testPutContainerData() {
 217         final InstanceIdentifierContext<DataSchemaNode> iidContext =
 218                 new InstanceIdentifierContext<>(this.iid2, this.schemaNode2, null, this.schema);
 219         final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseCont);
 220
 221         doReturn(this.readWrite).when(this.transactionChain).newReadWriteTransaction();
 222         doReturn(immediateFalseFluentFuture())
 223                 .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iid2);
 224         doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION,
 225                 payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData());
 226         doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit();
 227
 228         PutDataTransactionUtil.putData(payload, this.schema, new MdsalRestconfStrategy(transactionChainHandler),
 229                 null, null);
 230         verify(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION,
 231                 payload.getInstanceIdentifierContext().getInstanceIdentifier());
 232         verify(this.readWrite).put(LogicalDatastoreType.CONFIGURATION,
 233                 payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData());
 234     }
 235
 236     @Test
 237     public void testPutCreateContainerData() {
 238         final InstanceIdentifierContext<DataSchemaNode> iidContext =
 239                 new InstanceIdentifierContext<>(this.iid2, this.schemaNode2, null, this.schema);
 240         final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseCont);
 241
 242         doReturn(immediateFluentFuture(Optional.empty())).when(this.netconfService).getConfig(this.iid2);
 243         doReturn(CommitInfo.emptyFluentFuture()).when(this.netconfService).commit(Mockito.any());
 244
 245         PutDataTransactionUtil.putData(payload, this.schema, new NetconfRestconfStrategy(netconfService),
 246                 null, null);
 247         verify(this.netconfService).getConfig(payload.getInstanceIdentifierContext().getInstanceIdentifier());
 248         verify(this.netconfService).replace(LogicalDatastoreType.CONFIGURATION,
 249                 payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData(), Optional.empty());
 250     }
 251
 252     @Test
 253     public void testPutReplaceContainerData() {
 254         final InstanceIdentifierContext<DataSchemaNode> iidContext =
 255                 new InstanceIdentifierContext<>(this.iid2, this.schemaNode2, null, this.schema);
 256         final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseCont);
 257
 258         doReturn(immediateFluentFuture(Optional.of(mock(NormalizedNode.class))))
 259                 .when(this.netconfService).getConfig(this.iid2);
 260         doReturn(CommitInfo.emptyFluentFuture()).when(this.netconfService).commit(Mockito.any());
 261
 262         PutDataTransactionUtil.putData(payload, this.schema, new NetconfRestconfStrategy(netconfService),
 263                 null, null);
 264         verify(this.netconfService).getConfig(payload.getInstanceIdentifierContext().getInstanceIdentifier());
 265         verify(this.netconfService).replace(LogicalDatastoreType.CONFIGURATION,
 266                 payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData(), Optional.empty());
 267     }
 268
 269     @Test
 270     public void testPutLeafData() {
 271         final InstanceIdentifierContext<DataSchemaNode> iidContext =
 272                 new InstanceIdentifierContext<>(this.iid, this.schemaNode, null, this.schema);
 273         final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildLeaf);
 274
 275         doReturn(this.readWrite).when(this.transactionChain).newReadWriteTransaction();
 276         doReturn(immediateFalseFluentFuture())
 277                 .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iid);
 278         doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION,
 279                 payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData());
 280         doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit();
 281
 282         PutDataTransactionUtil.putData(payload, this.schema, new MdsalRestconfStrategy(transactionChainHandler),
 283                 null, null);
 284         verify(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION,
 285                 payload.getInstanceIdentifierContext().getInstanceIdentifier());
 286         verify(this.readWrite).put(LogicalDatastoreType.CONFIGURATION,
 287                 payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData());
 288     }
 289
 290     @Test
 291     public void testPutCreateLeafData() {
 292         final InstanceIdentifierContext<DataSchemaNode> iidContext =
 293                 new InstanceIdentifierContext<>(this.iid, this.schemaNode, null, this.schema);
 294         final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildLeaf);
 295
 296         doReturn(immediateFluentFuture(Optional.empty())).when(this.netconfService).getConfig(this.iid);
 297         doReturn(CommitInfo.emptyFluentFuture()).when(this.netconfService).commit(Mockito.any());
 298
 299         PutDataTransactionUtil.putData(payload, this.schema, new NetconfRestconfStrategy(netconfService),
 300                 null, null);
 301         verify(this.netconfService).getConfig(payload.getInstanceIdentifierContext().getInstanceIdentifier());
 302         verify(this.netconfService).replace(LogicalDatastoreType.CONFIGURATION,
 303                 payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData(), Optional.empty());
 304     }
 305
 306     @Test
 307     public void testPutReplaceLeafData() {
 308         final InstanceIdentifierContext<DataSchemaNode> iidContext =
 309                 new InstanceIdentifierContext<>(this.iid, this.schemaNode, null, this.schema);
 310         final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildLeaf);
 311
 312         doReturn(immediateFluentFuture(Optional.of(mock(NormalizedNode.class))))
 313                 .when(this.netconfService).getConfig(this.iid);
 314         doReturn(CommitInfo.emptyFluentFuture()).when(this.netconfService).commit(Mockito.any());
 315
 316         PutDataTransactionUtil.putData(payload, this.schema,
 317                 new NetconfRestconfStrategy(netconfService), null, null);
 318         verify(this.netconfService).getConfig(payload.getInstanceIdentifierContext().getInstanceIdentifier());
 319         verify(this.netconfService).replace(LogicalDatastoreType.CONFIGURATION,
 320                 payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData(), Optional.empty());
 321     }
 322
 323     @Test
 324     public void testPutListData() {
 325         final InstanceIdentifierContext<DataSchemaNode> iidContext =
 326                 new InstanceIdentifierContext<>(this.iid2, this.schemaNode2, null, this.schema);
 327         final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseContWithList);
 328
 329         doReturn(this.readWrite).when(this.transactionChain).newReadWriteTransaction();
 330         doReturn(immediateFalseFluentFuture())
 331                 .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iid2);
 332         doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION,
 333                 payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData());
 334         doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit();
 335         PutDataTransactionUtil.putData(payload, this.schema, new MdsalRestconfStrategy(transactionChainHandler),
 336                 null, null);
 337         verify(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iid2);
 338         verify(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, this.iid2, payload.getData());
 339     }
 340
 341     @Test
 342     public void testPutCreateListData() {
 343         final InstanceIdentifierContext<DataSchemaNode> iidContext =
 344                 new InstanceIdentifierContext<>(this.iid2, this.schemaNode2, null, this.schema);
 345         final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseContWithList);
 346
 347         doReturn(immediateFluentFuture(Optional.empty())).when(this.netconfService)
 348                 .getConfig(this.iid2);
 349         doReturn(CommitInfo.emptyFluentFuture()).when(this.netconfService).commit(Mockito.any());
 350
 351         PutDataTransactionUtil.putData(payload, this.schema, new NetconfRestconfStrategy(netconfService),
 352                 null, null);
 353         verify(this.netconfService).getConfig(this.iid2);
 354         verify(this.netconfService).replace(LogicalDatastoreType.CONFIGURATION, this.iid2,
 355                 payload.getData(), Optional.empty());
 356     }
 357
 358     @Test
 359     public void testPutReplaceListData() {
 360         final InstanceIdentifierContext<DataSchemaNode> iidContext =
 361                 new InstanceIdentifierContext<>(this.iid2, this.schemaNode2, null, this.schema);
 362         final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseContWithList);
 363
 364         doReturn(immediateFluentFuture(Optional.of(mock(NormalizedNode.class)))).when(this.netconfService)
 365                 .getConfig(this.iid2);
 366         doReturn(CommitInfo.emptyFluentFuture()).when(this.netconfService).commit(Mockito.any());
 367
 368         PutDataTransactionUtil.putData(payload, this.schema,
 369                 new NetconfRestconfStrategy(netconfService), null, null);
 370         verify(this.netconfService).getConfig(this.iid2);
 371         verify(this.netconfService).replace(LogicalDatastoreType.CONFIGURATION, this.iid2,
 372                 payload.getData(), Optional.empty());
 373     }
 374 }