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
8 package org.opendaylight.restconf.nb.rfc8040.rests.utils;
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;
17 import com.google.common.util.concurrent.Futures;
18 import java.util.Optional;
19 import org.junit.Before;
20 import org.junit.Test;
21 import org.junit.runner.RunWith;
22 import org.mockito.Mock;
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.spi.DefaultDOMRpcResult;
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.legacy.NormalizedNodePayload;
37 import org.opendaylight.restconf.nb.rfc8040.rests.services.impl.RestconfDataServiceImpl;
38 import org.opendaylight.restconf.nb.rfc8040.rests.transactions.MdsalRestconfStrategy;
39 import org.opendaylight.restconf.nb.rfc8040.rests.transactions.NetconfRestconfStrategy;
40 import org.opendaylight.yangtools.yang.common.QName;
41 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
42 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
43 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
44 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
45 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
46 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
47 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
48 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
49 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
50 import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
51 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
52 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
53 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
55 @RunWith(MockitoJUnitRunner.StrictStubs.class)
56 public class PutDataTransactionUtilTest {
57 private static final String PATH_FOR_NEW_SCHEMA_CONTEXT = "/jukebox";
60 private DOMDataTreeReadWriteTransaction readWrite;
62 private DOMDataTreeReadTransaction read;
64 private DOMDataTreeWriteTransaction write;
66 private DOMDataBroker mockDataBroker;
68 private NetconfDataTreeService netconfService;
70 private LeafNode<?> buildLeaf;
71 private ContainerNode buildBaseCont;
72 private ContainerNode buildBaseContWithList;
73 private MapEntryNode buildListEntry;
74 private EffectiveModelContext schema;
75 private DataSchemaNode schemaNode;
76 private YangInstanceIdentifier iid;
77 private DataSchemaNode schemaNode2;
78 private YangInstanceIdentifier iid2;
79 private DataSchemaNode schemaNode3;
80 private YangInstanceIdentifier iid3;
83 public void setUp() throws Exception {
85 YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles(PATH_FOR_NEW_SCHEMA_CONTEXT));
87 final QName baseQName = QName.create("http://example.com/ns/example-jukebox", "2015-04-04", "jukebox");
88 final QName containerQname = QName.create(baseQName, "player");
89 final QName leafQname = QName.create(baseQName, "gap");
90 final QName listQname = QName.create(baseQName, "playlist");
91 final QName listKeyQname = QName.create(baseQName, "name");
93 final NodeIdentifierWithPredicates nodeWithKey =
94 NodeIdentifierWithPredicates.of(listQname, listKeyQname, "name of band");
95 final NodeIdentifierWithPredicates nodeWithKey2 =
96 NodeIdentifierWithPredicates.of(listQname, listKeyQname, "name of band 2");
98 final DataSchemaContextTree tree = DataSchemaContextTree.from(schema);
99 iid = YangInstanceIdentifier.builder()
101 .node(containerQname)
104 schemaNode = tree.findChild(iid).orElseThrow().getDataSchemaNode();
106 iid2 = YangInstanceIdentifier.builder()
109 schemaNode2 = tree.findChild(iid2).orElseThrow().getDataSchemaNode();
111 iid3 = YangInstanceIdentifier.builder()
116 schemaNode3 = tree.findChild(iid3).orElseThrow().getDataSchemaNode();
118 buildLeaf = Builders.leafBuilder()
119 .withNodeIdentifier(new NodeIdentifier(leafQname))
122 final ContainerNode buildPlayerCont = Builders.containerBuilder()
123 .withNodeIdentifier(new NodeIdentifier(containerQname))
124 .withChild(buildLeaf)
126 buildBaseCont = Builders.containerBuilder()
127 .withNodeIdentifier(new NodeIdentifier(baseQName))
128 .withChild(buildPlayerCont)
130 final LeafNode<Object> content = Builders.leafBuilder()
131 .withNodeIdentifier(new NodeIdentifier(QName.create(baseQName, "name")))
132 .withValue("name of band")
134 final LeafNode<Object> content2 = Builders.leafBuilder()
135 .withNodeIdentifier(new NodeIdentifier(QName.create(baseQName, "description")))
136 .withValue("band description")
138 buildListEntry = Builders.mapEntryBuilder()
139 .withNodeIdentifier(nodeWithKey)
143 final LeafNode<Object> content3 = Builders.leafBuilder()
144 .withNodeIdentifier(new NodeIdentifier(QName.create(baseQName, "name")))
145 .withValue("name of band 2")
147 final LeafNode<Object> content4 = Builders.leafBuilder()
148 .withNodeIdentifier(new NodeIdentifier(QName.create(baseQName, "description")))
149 .withValue("band description 2")
151 final MapEntryNode buildListEntry2 = Builders.mapEntryBuilder()
152 .withNodeIdentifier(nodeWithKey2)
156 final MapNode buildList = Builders.mapBuilder()
157 .withNodeIdentifier(new NodeIdentifier(listQname))
158 .withChild(buildListEntry)
159 .withChild(buildListEntry2)
161 buildBaseContWithList = Builders.containerBuilder()
162 .withNodeIdentifier(new NodeIdentifier(baseQName))
163 .withChild(buildList)
166 doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).lock();
167 doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).unlock();
171 public void testValidInputData() {
172 final InstanceIdentifierContext<DataSchemaNode> iidContext =
173 new InstanceIdentifierContext<>(iid, schemaNode, null, schema);
174 final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, buildLeaf);
175 RestconfDataServiceImpl.validInputData(iidContext.getSchemaNode(), payload);
179 public void testValidTopLevelNodeName() {
180 InstanceIdentifierContext<DataSchemaNode> iidContext =
181 new InstanceIdentifierContext<>(iid, schemaNode, null, schema);
182 NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, buildLeaf);
183 RestconfDataServiceImpl.validTopLevelNodeName(iidContext.getInstanceIdentifier(), payload);
185 iidContext = new InstanceIdentifierContext<>(iid2, schemaNode2, null, schema);
186 payload = new NormalizedNodeContext(iidContext, buildBaseCont);
187 RestconfDataServiceImpl.validTopLevelNodeName(iidContext.getInstanceIdentifier(), payload);
190 @Test(expected = RestconfDocumentedException.class)
191 public void testValidTopLevelNodeNamePathEmpty() {
192 final InstanceIdentifierContext<DataSchemaNode> iidContext =
193 new InstanceIdentifierContext<>(iid, schemaNode, null, schema);
194 final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, buildLeaf);
195 RestconfDataServiceImpl.validTopLevelNodeName(YangInstanceIdentifier.empty(), payload);
198 @Test(expected = RestconfDocumentedException.class)
199 public void testValidTopLevelNodeNameWrongTopIdentifier() {
200 final InstanceIdentifierContext<DataSchemaNode> iidContext =
201 new InstanceIdentifierContext<>(iid, schemaNode, null, schema);
202 final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, buildLeaf);
203 RestconfDataServiceImpl.validTopLevelNodeName(iid.getAncestor(1), payload);
207 public void testValidateListKeysEqualityInPayloadAndUri() {
208 final InstanceIdentifierContext<DataSchemaNode> iidContext =
209 new InstanceIdentifierContext<>(iid3, schemaNode3, null, schema);
210 final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, buildListEntry);
211 RestconfDataServiceImpl.validateListKeysEqualityInPayloadAndUri(payload);
215 public void testPutContainerData() {
216 final InstanceIdentifierContext<DataSchemaNode> iidContext =
217 new InstanceIdentifierContext<>(iid2, schemaNode2, null, schema);
218 final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseCont);
220 doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction();
221 doReturn(read).when(mockDataBroker).newReadOnlyTransaction();
222 doReturn(immediateFalseFluentFuture())
223 .when(read).exists(LogicalDatastoreType.CONFIGURATION, iid2);
224 doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION,
225 payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData());
226 doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
228 PutDataTransactionUtil.putData(payload, schema, new MdsalRestconfStrategy(mockDataBroker), null, null);
229 verify(read).exists(LogicalDatastoreType.CONFIGURATION,
230 payload.getInstanceIdentifierContext().getInstanceIdentifier());
231 verify(readWrite).put(LogicalDatastoreType.CONFIGURATION,
232 payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData());
236 public void testPutCreateContainerData() {
237 final InstanceIdentifierContext<DataSchemaNode> iidContext =
238 new InstanceIdentifierContext<>(iid2, schemaNode2, null, schema);
239 final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseCont);
241 doReturn(immediateFluentFuture(Optional.empty())).when(netconfService).getConfig(iid2);
242 doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit();
243 doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService)
244 .replace(LogicalDatastoreType.CONFIGURATION, payload.getInstanceIdentifierContext().getInstanceIdentifier(),
245 payload.getData(), Optional.empty());
247 PutDataTransactionUtil.putData(payload, schema, new NetconfRestconfStrategy(netconfService),
249 verify(netconfService).lock();
250 verify(netconfService).getConfig(payload.getInstanceIdentifierContext().getInstanceIdentifier());
251 verify(netconfService).replace(LogicalDatastoreType.CONFIGURATION,
252 payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData(), Optional.empty());
256 public void testPutReplaceContainerData() {
257 final InstanceIdentifierContext<DataSchemaNode> iidContext =
258 new InstanceIdentifierContext<>(iid2, schemaNode2, null, schema);
259 final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseCont);
261 doReturn(immediateFluentFuture(Optional.of(mock(NormalizedNode.class))))
262 .when(netconfService).getConfig(iid2);
263 doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit();
264 doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService)
265 .replace(LogicalDatastoreType.CONFIGURATION,
266 payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData(), Optional.empty());
268 PutDataTransactionUtil.putData(payload, schema, new NetconfRestconfStrategy(netconfService),
270 verify(netconfService).getConfig(payload.getInstanceIdentifierContext().getInstanceIdentifier());
271 verify(netconfService).replace(LogicalDatastoreType.CONFIGURATION,
272 payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData(), Optional.empty());
276 public void testPutLeafData() {
277 final InstanceIdentifierContext<DataSchemaNode> iidContext =
278 new InstanceIdentifierContext<>(iid, schemaNode, null, schema);
279 final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildLeaf);
281 doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction();
282 doReturn(read).when(mockDataBroker).newReadOnlyTransaction();
283 doReturn(immediateFalseFluentFuture())
284 .when(read).exists(LogicalDatastoreType.CONFIGURATION, iid);
285 doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION,
286 payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData());
287 doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
289 PutDataTransactionUtil.putData(payload, schema, new MdsalRestconfStrategy(mockDataBroker), null, null);
290 verify(read).exists(LogicalDatastoreType.CONFIGURATION,
291 payload.getInstanceIdentifierContext().getInstanceIdentifier());
292 verify(readWrite).put(LogicalDatastoreType.CONFIGURATION,
293 payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData());
297 public void testPutCreateLeafData() {
298 final InstanceIdentifierContext<DataSchemaNode> iidContext =
299 new InstanceIdentifierContext<>(iid, schemaNode, null, schema);
300 final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildLeaf);
302 doReturn(immediateFluentFuture(Optional.empty())).when(netconfService).getConfig(iid);
303 doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit();
304 doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService)
305 .replace(LogicalDatastoreType.CONFIGURATION,
306 payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData(), Optional.empty());
308 PutDataTransactionUtil.putData(payload, schema, new NetconfRestconfStrategy(netconfService),
310 verify(netconfService).getConfig(payload.getInstanceIdentifierContext().getInstanceIdentifier());
311 verify(netconfService).replace(LogicalDatastoreType.CONFIGURATION,
312 payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData(), Optional.empty());
316 public void testPutReplaceLeafData() {
317 final InstanceIdentifierContext<DataSchemaNode> iidContext =
318 new InstanceIdentifierContext<>(iid, schemaNode, null, schema);
319 final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildLeaf);
321 doReturn(immediateFluentFuture(Optional.of(mock(NormalizedNode.class))))
322 .when(netconfService).getConfig(iid);
323 doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit();
324 doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService)
325 .replace(LogicalDatastoreType.CONFIGURATION,
326 payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData(), Optional.empty());
328 PutDataTransactionUtil.putData(payload, schema,
329 new NetconfRestconfStrategy(netconfService), null, null);
330 verify(netconfService).getConfig(payload.getInstanceIdentifierContext().getInstanceIdentifier());
331 verify(netconfService).replace(LogicalDatastoreType.CONFIGURATION,
332 payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData(), Optional.empty());
336 public void testPutListData() {
337 final InstanceIdentifierContext<DataSchemaNode> iidContext =
338 new InstanceIdentifierContext<>(iid2, schemaNode2, null, schema);
339 final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseContWithList);
341 doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction();
342 doReturn(read).when(mockDataBroker).newReadOnlyTransaction();
343 doReturn(immediateFalseFluentFuture())
344 .when(read).exists(LogicalDatastoreType.CONFIGURATION, iid2);
345 doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION,
346 payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData());
347 doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
348 PutDataTransactionUtil.putData(payload, schema, new MdsalRestconfStrategy(mockDataBroker), null, null);
349 verify(read).exists(LogicalDatastoreType.CONFIGURATION, iid2);
350 verify(readWrite).put(LogicalDatastoreType.CONFIGURATION, iid2, payload.getData());
354 public void testPutCreateListData() {
355 final InstanceIdentifierContext<DataSchemaNode> iidContext =
356 new InstanceIdentifierContext<>(iid2, schemaNode2, null, schema);
357 final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseContWithList);
359 doReturn(immediateFluentFuture(Optional.empty())).when(netconfService)
361 doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit();
362 doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService)
363 .replace(LogicalDatastoreType.CONFIGURATION, iid2, payload.getData(), Optional.empty());
365 PutDataTransactionUtil.putData(payload, schema, new NetconfRestconfStrategy(netconfService),
367 verify(netconfService).getConfig(iid2);
368 verify(netconfService).replace(LogicalDatastoreType.CONFIGURATION, iid2,
369 payload.getData(), Optional.empty());
373 public void testPutReplaceListData() {
374 final InstanceIdentifierContext<DataSchemaNode> iidContext =
375 new InstanceIdentifierContext<>(iid2, schemaNode2, null, schema);
376 final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseContWithList);
378 doReturn(immediateFluentFuture(Optional.of(mock(NormalizedNode.class)))).when(netconfService)
380 doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit();
381 doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService)
382 .replace(LogicalDatastoreType.CONFIGURATION,
383 iid2, payload.getData(), Optional.empty());
385 PutDataTransactionUtil.putData(payload, schema,
386 new NetconfRestconfStrategy(netconfService), null, null);
387 verify(netconfService).getConfig(iid2);
388 verify(netconfService).replace(LogicalDatastoreType.CONFIGURATION, iid2,
389 payload.getData(), Optional.empty());