X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=restconf%2Frestconf-nb-rfc8040%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Frestconf%2Fnb%2Frfc8040%2Frests%2Futils%2FPutDataTransactionUtilTest.java;h=7b2f84907d01f62dcc9e433b782d6cadd6181f6a;hb=9cc114dc8e4109893e2346477b5ae14391afe01c;hp=27a0a0631f044da279b7555a16da20e8d76ba2c5;hpb=9e7adec1a8dfe5dd84dcb7317280572aab20e668;p=netconf.git diff --git a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/PutDataTransactionUtilTest.java b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/PutDataTransactionUtilTest.java index 27a0a0631f..7b2f84907d 100644 --- a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/PutDataTransactionUtilTest.java +++ b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/PutDataTransactionUtilTest.java @@ -7,30 +7,37 @@ */ package org.opendaylight.restconf.nb.rfc8040.rests.utils; +import static org.junit.Assert.assertThrows; import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFalseFluentFuture; +import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFluentFuture; +import com.google.common.util.concurrent.Futures; +import java.util.Optional; import org.junit.Before; import org.junit.Test; +import org.junit.runner.RunWith; import org.mockito.Mock; -import org.mockito.Mockito; -import org.mockito.MockitoAnnotations; +import org.mockito.junit.MockitoJUnitRunner; import org.opendaylight.mdsal.common.api.CommitInfo; import org.opendaylight.mdsal.common.api.LogicalDatastoreType; import org.opendaylight.mdsal.dom.api.DOMDataBroker; import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction; import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction; import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction; -import org.opendaylight.mdsal.dom.api.DOMTransactionChain; +import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult; +import org.opendaylight.netconf.dom.api.NetconfDataTreeService; import org.opendaylight.restconf.common.context.InstanceIdentifierContext; -import org.opendaylight.restconf.common.context.NormalizedNodeContext; import org.opendaylight.restconf.common.errors.RestconfDocumentedException; import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils; -import org.opendaylight.restconf.nb.rfc8040.handlers.TransactionChainHandler; -import org.opendaylight.restconf.nb.rfc8040.references.SchemaContextRef; -import org.opendaylight.restconf.nb.rfc8040.rests.transactions.TransactionVarsWrapper; +import org.opendaylight.restconf.nb.rfc8040.WriteDataParams; +import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload; +import org.opendaylight.restconf.nb.rfc8040.rests.services.impl.RestconfDataServiceImpl; +import org.opendaylight.restconf.nb.rfc8040.rests.transactions.MdsalRestconfStrategy; +import org.opendaylight.restconf.nb.rfc8040.rests.transactions.NetconfRestconfStrategy; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier; @@ -39,18 +46,17 @@ import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode; import org.opendaylight.yangtools.yang.data.api.schema.LeafNode; import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode; import org.opendaylight.yangtools.yang.data.api.schema.MapNode; +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.opendaylight.yangtools.yang.data.impl.schema.Builders; import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree; import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; -import org.opendaylight.yangtools.yang.model.api.SchemaContext; +import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext; import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils; +@RunWith(MockitoJUnitRunner.StrictStubs.class) public class PutDataTransactionUtilTest { - private static final String PATH_FOR_NEW_SCHEMA_CONTEXT = "/jukebox"; - @Mock - private DOMTransactionChain transactionChain; @Mock private DOMDataTreeReadWriteTransaction readWrite; @Mock @@ -59,14 +65,14 @@ public class PutDataTransactionUtilTest { private DOMDataTreeWriteTransaction write; @Mock private DOMDataBroker mockDataBroker; + @Mock + private NetconfDataTreeService netconfService; - private TransactionChainHandler transactionChainHandler; - private SchemaContextRef refSchemaCtx; - private LeafNode buildLeaf; + private LeafNode buildLeaf; private ContainerNode buildBaseCont; private ContainerNode buildBaseContWithList; private MapEntryNode buildListEntry; - private SchemaContext schema; + private EffectiveModelContext schema; private DataSchemaNode schemaNode; private YangInstanceIdentifier iid; private DataSchemaNode schemaNode2; @@ -76,10 +82,8 @@ public class PutDataTransactionUtilTest { @Before public void setUp() throws Exception { - MockitoAnnotations.initMocks(this); - this.refSchemaCtx = new SchemaContextRef( - YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles(PATH_FOR_NEW_SCHEMA_CONTEXT))); - this.schema = this.refSchemaCtx.get(); + schema = + YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles(PATH_FOR_NEW_SCHEMA_CONTEXT)); final QName baseQName = QName.create("http://example.com/ns/example-jukebox", "2015-04-04", "jukebox"); final QName containerQname = QName.create(baseQName, "player"); @@ -92,34 +96,35 @@ public class PutDataTransactionUtilTest { final NodeIdentifierWithPredicates nodeWithKey2 = NodeIdentifierWithPredicates.of(listQname, listKeyQname, "name of band 2"); - this.iid = YangInstanceIdentifier.builder() + final DataSchemaContextTree tree = DataSchemaContextTree.from(schema); + iid = YangInstanceIdentifier.builder() .node(baseQName) .node(containerQname) .node(leafQname) .build(); - this.schemaNode = DataSchemaContextTree.from(this.schema).getChild(this.iid).getDataSchemaNode(); + schemaNode = tree.findChild(iid).orElseThrow().getDataSchemaNode(); - this.iid2 = YangInstanceIdentifier.builder() + iid2 = YangInstanceIdentifier.builder() .node(baseQName) .build(); - this.schemaNode2 = DataSchemaContextTree.from(this.schema).getChild(this.iid2).getDataSchemaNode(); + schemaNode2 = tree.findChild(iid2).orElseThrow().getDataSchemaNode(); - this.iid3 = YangInstanceIdentifier.builder() + iid3 = YangInstanceIdentifier.builder() .node(baseQName) .node(listQname) .node(nodeWithKey) .build(); - this.schemaNode3 = DataSchemaContextTree.from(this.schema).getChild(this.iid3).getDataSchemaNode(); + schemaNode3 = tree.findChild(iid3).orElseThrow().getDataSchemaNode(); - this.buildLeaf = Builders.leafBuilder() + buildLeaf = Builders.leafBuilder() .withNodeIdentifier(new NodeIdentifier(leafQname)) .withValue(0.2) .build(); final ContainerNode buildPlayerCont = Builders.containerBuilder() .withNodeIdentifier(new NodeIdentifier(containerQname)) - .withChild(this.buildLeaf) + .withChild(buildLeaf) .build(); - this.buildBaseCont = Builders.containerBuilder() + buildBaseCont = Builders.containerBuilder() .withNodeIdentifier(new NodeIdentifier(baseQName)) .withChild(buildPlayerCont) .build(); @@ -131,7 +136,7 @@ public class PutDataTransactionUtilTest { .withNodeIdentifier(new NodeIdentifier(QName.create(baseQName, "description"))) .withValue("band description") .build(); - this.buildListEntry = Builders.mapEntryBuilder() + buildListEntry = Builders.mapEntryBuilder() .withNodeIdentifier(nodeWithKey) .withChild(content) .withChild(content2) @@ -151,128 +156,220 @@ public class PutDataTransactionUtilTest { .build(); final MapNode buildList = Builders.mapBuilder() .withNodeIdentifier(new NodeIdentifier(listQname)) - .withChild(this.buildListEntry) + .withChild(buildListEntry) .withChild(buildListEntry2) .build(); - this.buildBaseContWithList = Builders.containerBuilder() + buildBaseContWithList = Builders.containerBuilder() .withNodeIdentifier(new NodeIdentifier(baseQName)) .withChild(buildList) .build(); - Mockito.doReturn(transactionChain).when(mockDataBroker).createTransactionChain(Mockito.any()); - transactionChainHandler = new TransactionChainHandler(mockDataBroker); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).lock(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).unlock(); } @Test - public void testValidInputData() throws Exception { - final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iid, this.schemaNode, null, this.schema); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildLeaf); - PutDataTransactionUtil.validInputData(iidContext.getSchemaNode(), payload); + public void testValidInputData() { + RestconfDataServiceImpl.validInputData(schemaNode, NormalizedNodePayload.of( + new InstanceIdentifierContext(iid, schemaNode, null, schema), buildLeaf)); } @Test - public void testValidTopLevelNodeName() throws Exception { - InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iid, this.schemaNode, null, this.schema); - NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildLeaf); - PutDataTransactionUtil.validTopLevelNodeName(iidContext.getInstanceIdentifier(), payload); - - iidContext = new InstanceIdentifierContext<>(this.iid2, this.schemaNode2, null, this.schema); - payload = new NormalizedNodeContext(iidContext, this.buildBaseCont); - PutDataTransactionUtil.validTopLevelNodeName(iidContext.getInstanceIdentifier(), payload); + public void testValidTopLevelNodeName() { + RestconfDataServiceImpl.validTopLevelNodeName(iid, NormalizedNodePayload.of( + new InstanceIdentifierContext(iid, schemaNode, null, schema), buildLeaf)); + RestconfDataServiceImpl.validTopLevelNodeName(iid2, NormalizedNodePayload.of( + new InstanceIdentifierContext(iid2, schemaNode2, null, schema), buildBaseCont)); } - @Test(expected = RestconfDocumentedException.class) - public void testValidTopLevelNodeNamePathEmpty() throws Exception { - final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iid, this.schemaNode, null, this.schema); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildLeaf); - PutDataTransactionUtil.validTopLevelNodeName(YangInstanceIdentifier.empty(), payload); + @Test + public void testValidTopLevelNodeNamePathEmpty() { + final InstanceIdentifierContext iidContext = + new InstanceIdentifierContext(iid, schemaNode, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildLeaf); + + // FIXME: more asserts + assertThrows(RestconfDocumentedException.class, + () -> RestconfDataServiceImpl.validTopLevelNodeName(YangInstanceIdentifier.empty(), payload)); } - @Test(expected = RestconfDocumentedException.class) - public void testValidTopLevelNodeNameWrongTopIdentifier() throws Exception { - final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iid, this.schemaNode, null, this.schema); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildLeaf); - PutDataTransactionUtil.validTopLevelNodeName(this.iid.getAncestor(1), payload); + @Test + public void testValidTopLevelNodeNameWrongTopIdentifier() { + final InstanceIdentifierContext iidContext = + new InstanceIdentifierContext(iid, schemaNode, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildLeaf); + + // FIXME: more asserts + assertThrows(RestconfDocumentedException.class, + () -> RestconfDataServiceImpl.validTopLevelNodeName(iid.getAncestor(1), payload)); } @Test - public void testValidateListKeysEqualityInPayloadAndUri() throws Exception { - final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iid3, this.schemaNode3, null, this.schema); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildListEntry); - PutDataTransactionUtil.validateListKeysEqualityInPayloadAndUri(payload); + public void testValidateListKeysEqualityInPayloadAndUri() { + final InstanceIdentifierContext iidContext = + new InstanceIdentifierContext(iid3, schemaNode3, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildListEntry); + RestconfDataServiceImpl.validateListKeysEqualityInPayloadAndUri(payload); } @Test - public void testPutContainerData() throws Exception { - final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iid2, this.schemaNode2, null, this.schema); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseCont); - - doReturn(this.readWrite).when(this.transactionChain).newReadWriteTransaction(); - doReturn(this.read).when(this.transactionChain).newReadOnlyTransaction(); - doReturn(this.write).when(this.transactionChain).newWriteOnlyTransaction(); - doReturn(immediateFalseFluentFuture()) - .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iid2); - doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, - payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData()); - doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit(); - - PutDataTransactionUtil.putData(payload, this.refSchemaCtx, - new TransactionVarsWrapper(payload.getInstanceIdentifierContext(), null, transactionChainHandler), null, - null); - verify(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, - payload.getInstanceIdentifierContext().getInstanceIdentifier()); - verify(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, - payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData()); + public void testPutContainerData() { + final InstanceIdentifierContext iidContext = + new InstanceIdentifierContext(iid2, schemaNode2, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseCont); + + doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction(); + doReturn(read).when(mockDataBroker).newReadOnlyTransaction(); + doReturn(immediateFalseFluentFuture()).when(read).exists(LogicalDatastoreType.CONFIGURATION, iid2); + doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, iid2, payload.getData()); + doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit(); + + PutDataTransactionUtil.putData(payload, schema, new MdsalRestconfStrategy(mockDataBroker), + WriteDataParams.empty()); + verify(read).exists(LogicalDatastoreType.CONFIGURATION, iid2); + verify(readWrite).put(LogicalDatastoreType.CONFIGURATION, iid2, payload.getData()); } @Test - public void testPutleafData() throws Exception { - final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iid, this.schemaNode, null, this.schema); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildLeaf); - - doReturn(this.readWrite).when(this.transactionChain).newReadWriteTransaction(); - doReturn(this.read).when(this.transactionChain).newReadOnlyTransaction(); - doReturn(this.write).when(this.transactionChain).newWriteOnlyTransaction(); - doReturn(immediateFalseFluentFuture()) - .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iid); - doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, - payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData()); - doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit(); - - PutDataTransactionUtil.putData(payload, this.refSchemaCtx, - new TransactionVarsWrapper(payload.getInstanceIdentifierContext(), null, transactionChainHandler), null, - null); - verify(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, - payload.getInstanceIdentifierContext().getInstanceIdentifier()); - verify(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, - payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData()); + public void testPutCreateContainerData() { + final InstanceIdentifierContext iidContext = + new InstanceIdentifierContext(iid2, schemaNode2, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseCont); + + doReturn(immediateFluentFuture(Optional.empty())).when(netconfService).getConfig(iid2); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService) + .replace(LogicalDatastoreType.CONFIGURATION, iid2, payload.getData(), Optional.empty()); + + PutDataTransactionUtil.putData(payload, schema, new NetconfRestconfStrategy(netconfService), + WriteDataParams.empty()); + verify(netconfService).lock(); + verify(netconfService).getConfig(iid2); + verify(netconfService).replace(LogicalDatastoreType.CONFIGURATION, iid2, payload.getData(), Optional.empty()); + } + + @Test + public void testPutReplaceContainerData() { + final InstanceIdentifierContext iidContext = + new InstanceIdentifierContext(iid2, schemaNode2, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseCont); + + doReturn(immediateFluentFuture(Optional.of(mock(NormalizedNode.class)))).when(netconfService).getConfig(iid2); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService) + .replace(LogicalDatastoreType.CONFIGURATION, iid2, payload.getData(), Optional.empty()); + + PutDataTransactionUtil.putData(payload, schema, new NetconfRestconfStrategy(netconfService), + WriteDataParams.empty()); + verify(netconfService).getConfig(iid2); + verify(netconfService).replace(LogicalDatastoreType.CONFIGURATION, iid2, payload.getData(), Optional.empty()); + } + + @Test + public void testPutLeafData() { + final InstanceIdentifierContext iidContext = + new InstanceIdentifierContext(iid, schemaNode, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildLeaf); + + doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction(); + doReturn(read).when(mockDataBroker).newReadOnlyTransaction(); + doReturn(immediateFalseFluentFuture()).when(read).exists(LogicalDatastoreType.CONFIGURATION, iid); + doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, iid, payload.getData()); + doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit(); + + PutDataTransactionUtil.putData(payload, schema, new MdsalRestconfStrategy(mockDataBroker), + WriteDataParams.empty()); + verify(read).exists(LogicalDatastoreType.CONFIGURATION, iid); + verify(readWrite).put(LogicalDatastoreType.CONFIGURATION, iid, payload.getData()); + } + + @Test + public void testPutCreateLeafData() { + final InstanceIdentifierContext iidContext = + new InstanceIdentifierContext(iid, schemaNode, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildLeaf); + + doReturn(immediateFluentFuture(Optional.empty())).when(netconfService).getConfig(iid); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService) + .replace(LogicalDatastoreType.CONFIGURATION, iid, payload.getData(), Optional.empty()); + + PutDataTransactionUtil.putData(payload, schema, new NetconfRestconfStrategy(netconfService), + WriteDataParams.empty()); + verify(netconfService).getConfig(iid); + verify(netconfService).replace(LogicalDatastoreType.CONFIGURATION, iid, payload.getData(), Optional.empty()); + } + + @Test + public void testPutReplaceLeafData() { + final InstanceIdentifierContext iidContext = + new InstanceIdentifierContext(iid, schemaNode, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildLeaf); + + doReturn(immediateFluentFuture(Optional.of(mock(NormalizedNode.class)))).when(netconfService).getConfig(iid); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService) + .replace(LogicalDatastoreType.CONFIGURATION, iid, payload.getData(), Optional.empty()); + + PutDataTransactionUtil.putData(payload, schema, new NetconfRestconfStrategy(netconfService), + WriteDataParams.empty()); + verify(netconfService).getConfig(iid); + verify(netconfService).replace(LogicalDatastoreType.CONFIGURATION, iid, payload.getData(), Optional.empty()); } @Test - public void testPutListData() throws Exception { - final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iid2, this.schemaNode2, null, this.schema); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseContWithList); - - doReturn(this.readWrite).when(this.transactionChain).newReadWriteTransaction(); - doReturn(this.read).when(this.transactionChain).newReadOnlyTransaction(); - doReturn(this.write).when(this.transactionChain).newWriteOnlyTransaction(); + public void testPutListData() { + final InstanceIdentifierContext iidContext = + new InstanceIdentifierContext(iid2, schemaNode2, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseContWithList); + + doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction(); + doReturn(read).when(mockDataBroker).newReadOnlyTransaction(); doReturn(immediateFalseFluentFuture()) - .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iid2); - doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, - payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData()); - doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit(); - PutDataTransactionUtil.putData(payload, this.refSchemaCtx, - new TransactionVarsWrapper(payload.getInstanceIdentifierContext(), null, transactionChainHandler), null, - null); - verify(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iid2); - verify(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, this.iid2, payload.getData()); + .when(read).exists(LogicalDatastoreType.CONFIGURATION, iid2); + doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, iid2, payload.getData()); + doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit(); + PutDataTransactionUtil.putData(payload, schema, new MdsalRestconfStrategy(mockDataBroker), + WriteDataParams.empty()); + verify(read).exists(LogicalDatastoreType.CONFIGURATION, iid2); + verify(readWrite).put(LogicalDatastoreType.CONFIGURATION, iid2, payload.getData()); + } + + @Test + public void testPutCreateListData() { + final InstanceIdentifierContext iidContext = + new InstanceIdentifierContext(iid2, schemaNode2, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseContWithList); + + doReturn(immediateFluentFuture(Optional.empty())).when(netconfService) + .getConfig(iid2); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService) + .replace(LogicalDatastoreType.CONFIGURATION, iid2, payload.getData(), Optional.empty()); + + PutDataTransactionUtil.putData(payload, schema, new NetconfRestconfStrategy(netconfService), + WriteDataParams.empty()); + verify(netconfService).getConfig(iid2); + verify(netconfService).replace(LogicalDatastoreType.CONFIGURATION, iid2, + payload.getData(), Optional.empty()); + } + + @Test + public void testPutReplaceListData() { + final InstanceIdentifierContext iidContext = + new InstanceIdentifierContext(iid2, schemaNode2, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseContWithList); + + doReturn(immediateFluentFuture(Optional.of(mock(NormalizedNode.class)))).when(netconfService) + .getConfig(iid2); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService) + .replace(LogicalDatastoreType.CONFIGURATION, + iid2, payload.getData(), Optional.empty()); + + PutDataTransactionUtil.putData(payload, schema, new NetconfRestconfStrategy(netconfService), + WriteDataParams.empty()); + verify(netconfService).getConfig(iid2); + verify(netconfService).replace(LogicalDatastoreType.CONFIGURATION, iid2, payload.getData(), Optional.empty()); } }