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%2Fservices%2Fimpl%2FRestconfDataServiceImplTest.java;h=84a142ab3b10fa2c963851b374bc027d8c08d0f5;hb=9cc114dc8e4109893e2346477b5ae14391afe01c;hp=49e854b7b1f4ac1d1668790add94ad66f3ab1870;hpb=407283022a89dfb7661164b6d872fa653fd7179c;p=netconf.git diff --git a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfDataServiceImplTest.java b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfDataServiceImplTest.java index 49e854b7b1..84a142ab3b 100644 --- a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfDataServiceImplTest.java +++ b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfDataServiceImplTest.java @@ -13,9 +13,9 @@ import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Mockito.doCallRealMethod; import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.opendaylight.restconf.common.patch.PatchEditOperation.CREATE; import static org.opendaylight.restconf.common.patch.PatchEditOperation.DELETE; import static org.opendaylight.restconf.common.patch.PatchEditOperation.REMOVE; @@ -26,10 +26,9 @@ import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediate import java.util.ArrayList; import java.util.Collection; -import java.util.Collections; -import java.util.HashSet; import java.util.List; import java.util.Optional; +import java.util.Set; import javax.ws.rs.core.MultivaluedHashMap; import javax.ws.rs.core.MultivaluedMap; import javax.ws.rs.core.Response; @@ -37,11 +36,12 @@ import javax.ws.rs.core.UriBuilder; import javax.ws.rs.core.UriInfo; 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.DOMActionService; import org.opendaylight.mdsal.dom.api.DOMDataBroker; import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction; import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction; @@ -50,19 +50,16 @@ import org.opendaylight.mdsal.dom.api.DOMMountPoint; import org.opendaylight.mdsal.dom.api.DOMMountPointService; import org.opendaylight.mdsal.dom.api.DOMSchemaService; import org.opendaylight.mdsal.dom.api.DOMTransactionChain; -import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener; +import org.opendaylight.mdsal.dom.spi.FixedDOMSchemaService; 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.common.patch.PatchContext; import org.opendaylight.restconf.common.patch.PatchEntity; import org.opendaylight.restconf.common.patch.PatchStatusContext; import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils; -import org.opendaylight.restconf.nb.rfc8040.handlers.ActionServiceHandler; -import org.opendaylight.restconf.nb.rfc8040.handlers.DOMMountPointServiceHandler; import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler; -import org.opendaylight.restconf.nb.rfc8040.handlers.TransactionChainHandler; +import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload; import org.opendaylight.restconf.nb.rfc8040.rests.services.api.RestconfStreamsSubscriptionService; import org.opendaylight.restconf.nb.rfc8040.rests.transactions.MdsalRestconfStrategy; import org.opendaylight.restconf.nb.rfc8040.rests.transactions.NetconfRestconfStrategy; @@ -72,7 +69,6 @@ import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates; -import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode; import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; import org.opendaylight.yangtools.yang.data.api.schema.LeafNode; @@ -80,14 +76,15 @@ 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.impl.schema.ImmutableNodes; import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder; import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree; import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext; import org.opendaylight.yangtools.yang.model.api.SchemaContext; -import org.opendaylight.yangtools.yang.model.api.SchemaNode; import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils; +@RunWith(MockitoJUnitRunner.StrictStubs.class) public class RestconfDataServiceImplTest { private static final String PATH_FOR_NEW_SCHEMA_CONTEXT = "/jukebox"; @@ -105,7 +102,6 @@ public class RestconfDataServiceImplTest { private ContainerNode buildPlayerCont; private ContainerNode buildLibraryCont; private MapNode buildPlaylistList; - private TransactionChainHandler transactionChainHandler; @Mock private DOMTransactionChain domTransactionChain; @@ -126,140 +122,131 @@ public class RestconfDataServiceImplTest { @Mock private NetconfDataTreeService netconfService; @Mock - private ActionServiceHandler actionServiceHandler; - @Mock - private DOMTransactionChain mountTransactionChain; + private DOMActionService actionService; @Mock private RestconfStreamsSubscriptionService delegRestconfSubscrService; @Mock private Configuration configuration; + @Mock + private MultivaluedMap queryParamenters; @Before public void setUp() throws Exception { - MockitoAnnotations.initMocks(this); - - final MultivaluedMap value = Mockito.mock(MultivaluedMap.class); - Mockito.when(value.entrySet()).thenReturn(new HashSet<>()); - Mockito.when(this.uriInfo.getQueryParameters()).thenReturn(value); + doReturn(Set.of()).when(queryParamenters).entrySet(); + doReturn(queryParamenters).when(uriInfo).getQueryParameters(); - this.baseQName = QName.create("http://example.com/ns/example-jukebox", "2015-04-04", "jukebox"); - this.containerPlayerQname = QName.create(this.baseQName, "player"); - this.leafQname = QName.create(this.baseQName, "gap"); + baseQName = QName.create("http://example.com/ns/example-jukebox", "2015-04-04", "jukebox"); + containerPlayerQname = QName.create(baseQName, "player"); + leafQname = QName.create(baseQName, "gap"); - final QName containerLibraryQName = QName.create(this.baseQName, "library"); - final QName listPlaylistQName = QName.create(this.baseQName, "playlist"); + final QName containerLibraryQName = QName.create(baseQName, "library"); + final QName listPlaylistQName = QName.create(baseQName, "playlist"); final LeafNode buildLeaf = Builders.leafBuilder() - .withNodeIdentifier(new NodeIdentifier(this.leafQname)) + .withNodeIdentifier(new NodeIdentifier(leafQname)) .withValue(0.2) .build(); - this.buildPlayerCont = Builders.containerBuilder() - .withNodeIdentifier(new NodeIdentifier(this.containerPlayerQname)) + buildPlayerCont = Builders.containerBuilder() + .withNodeIdentifier(new NodeIdentifier(containerPlayerQname)) .withChild(buildLeaf) .build(); - this.buildLibraryCont = Builders.containerBuilder() + buildLibraryCont = Builders.containerBuilder() .withNodeIdentifier(new NodeIdentifier(containerLibraryQName)) .build(); - this.buildPlaylistList = Builders.mapBuilder() + buildPlaylistList = Builders.mapBuilder() .withNodeIdentifier(new NodeIdentifier(listPlaylistQName)) .build(); - this.buildBaseCont = Builders.containerBuilder() - .withNodeIdentifier(new NodeIdentifier(this.baseQName)) - .withChild(this.buildPlayerCont) + buildBaseCont = Builders.containerBuilder() + .withNodeIdentifier(new NodeIdentifier(baseQName)) + .withChild(buildPlayerCont) .build(); // config contains one child the same as in operational and one additional - this.buildBaseContConfig = Builders.containerBuilder() - .withNodeIdentifier(new NodeIdentifier(this.baseQName)) - .withChild(this.buildPlayerCont) - .withChild(this.buildLibraryCont) + buildBaseContConfig = Builders.containerBuilder() + .withNodeIdentifier(new NodeIdentifier(baseQName)) + .withChild(buildPlayerCont) + .withChild(buildLibraryCont) .build(); // operational contains one child the same as in config and one additional - this.buildBaseContOperational = Builders.containerBuilder() - .withNodeIdentifier(new NodeIdentifier(this.baseQName)) - .withChild(this.buildPlayerCont) - .withChild(this.buildPlaylistList) + buildBaseContOperational = Builders.containerBuilder() + .withNodeIdentifier(new NodeIdentifier(baseQName)) + .withChild(buildPlayerCont) + .withChild(buildPlaylistList) .build(); - this.iidBase = YangInstanceIdentifier.builder() - .node(this.baseQName) + iidBase = YangInstanceIdentifier.builder() + .node(baseQName) .build(); - this.contextRef = + contextRef = YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles(PATH_FOR_NEW_SCHEMA_CONTEXT)); - this.schemaNode = DataSchemaContextTree.from(this.contextRef).getChild(this.iidBase).getDataSchemaNode(); + schemaNode = DataSchemaContextTree.from(contextRef).findChild(iidBase).orElseThrow( + ).getDataSchemaNode(); - doReturn(CommitInfo.emptyFluentFuture()).when(this.write).commit(); - doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit(); + doReturn(CommitInfo.emptyFluentFuture()).when(write).commit(); + doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit(); - doReturn(this.read).when(domTransactionChain).newReadOnlyTransaction(); - doReturn(this.readWrite).when(domTransactionChain).newReadWriteTransaction(); - doReturn(this.write).when(domTransactionChain).newWriteOnlyTransaction(); + DOMDataBroker mockDataBroker = mock(DOMDataBroker.class); + doReturn(read).when(mockDataBroker).newReadOnlyTransaction(); + doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction(); + doReturn(write).when(mockDataBroker).newWriteOnlyTransaction(); - DOMDataBroker mockDataBroker = Mockito.mock(DOMDataBroker.class); - Mockito.doReturn(domTransactionChain).when(mockDataBroker).createTransactionChain(Mockito.any()); + final SchemaContextHandler schemaContextHandler = new SchemaContextHandler( + mockDataBroker, mock(DOMSchemaService.class)); - transactionChainHandler = new TransactionChainHandler(mockDataBroker); - - final SchemaContextHandler schemaContextHandler = new SchemaContextHandler(transactionChainHandler, - Mockito.mock(DOMSchemaService.class)); - - schemaContextHandler.onModelContextUpdated(this.contextRef); - this.dataService = new RestconfDataServiceImpl(schemaContextHandler, this.transactionChainHandler, - new DOMMountPointServiceHandler(mountPointService), this.delegRestconfSubscrService, - this.actionServiceHandler, configuration); - doReturn(Optional.of(this.mountPoint)).when(this.mountPointService) + schemaContextHandler.onModelContextUpdated(contextRef); + dataService = new RestconfDataServiceImpl(schemaContextHandler, mockDataBroker, mountPointService, + delegRestconfSubscrService, actionService, configuration); + doReturn(Optional.of(mountPoint)).when(mountPointService) .getMountPoint(any(YangInstanceIdentifier.class)); - doCallRealMethod().when(this.mountPoint).getSchemaContext(); - doReturn(this.contextRef).when(this.mountPoint).getEffectiveModelContext(); - doReturn(Optional.of(this.mountDataBroker)).when(this.mountPoint).getService(DOMDataBroker.class); - doReturn(this.mountTransactionChain).when(this.mountDataBroker) - .createTransactionChain(any(DOMTransactionChainListener.class)); - doReturn(this.read).when(this.mountTransactionChain).newReadOnlyTransaction(); - doReturn(this.readWrite).when(this.mountTransactionChain).newReadWriteTransaction(); + doReturn(Optional.of(FixedDOMSchemaService.of(contextRef))).when(mountPoint) + .getService(DOMSchemaService.class); + doReturn(Optional.of(mountDataBroker)).when(mountPoint).getService(DOMDataBroker.class); + doReturn(Optional.empty()).when(mountPoint).getService(NetconfDataTreeService.class); + doReturn(read).when(mountDataBroker).newReadOnlyTransaction(); + doReturn(readWrite).when(mountDataBroker).newReadWriteTransaction(); } @Test public void testReadData() { - doReturn(new MultivaluedHashMap()).when(this.uriInfo).getQueryParameters(); - doReturn(immediateFluentFuture(Optional.of(this.buildBaseCont))).when(this.read) - .read(LogicalDatastoreType.CONFIGURATION, this.iidBase); + doReturn(new MultivaluedHashMap()).when(uriInfo).getQueryParameters(); + doReturn(immediateFluentFuture(Optional.of(buildBaseCont))).when(read) + .read(LogicalDatastoreType.CONFIGURATION, iidBase); doReturn(immediateFluentFuture(Optional.empty())) - .when(this.read).read(LogicalDatastoreType.OPERATIONAL, this.iidBase); - final Response response = this.dataService.readData("example-jukebox:jukebox", this.uriInfo); + .when(read).read(LogicalDatastoreType.OPERATIONAL, iidBase); + final Response response = dataService.readData("example-jukebox:jukebox", uriInfo); assertNotNull(response); assertEquals(200, response.getStatus()); - assertEquals(this.buildBaseCont, ((NormalizedNodeContext) response.getEntity()).getData()); + assertEquals(buildBaseCont, ((NormalizedNodePayload) response.getEntity()).getData()); } @Test public void testReadRootData() { - doReturn(new MultivaluedHashMap()).when(this.uriInfo).getQueryParameters(); - doReturn(immediateFluentFuture(Optional.of(wrapNodeByDataRootContainer(this.buildBaseContConfig)))) - .when(this.read) + doReturn(new MultivaluedHashMap()).when(uriInfo).getQueryParameters(); + doReturn(immediateFluentFuture(Optional.of(wrapNodeByDataRootContainer(buildBaseContConfig)))) + .when(read) .read(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.empty()); - doReturn(immediateFluentFuture(Optional.of(wrapNodeByDataRootContainer(this.buildBaseContOperational)))) - .when(this.read) + doReturn(immediateFluentFuture(Optional.of(wrapNodeByDataRootContainer(buildBaseContOperational)))) + .when(read) .read(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.empty()); - final Response response = this.dataService.readData(this.uriInfo); + final Response response = dataService.readData(uriInfo); assertNotNull(response); assertEquals(200, response.getStatus()); - final NormalizedNode data = ((NormalizedNodeContext) response.getEntity()).getData(); + final NormalizedNode data = ((NormalizedNodePayload) response.getEntity()).getData(); assertTrue(data instanceof ContainerNode); - final Collection> rootNodes = ((ContainerNode) data).getValue(); + final Collection rootNodes = ((ContainerNode) data).body(); assertEquals(1, rootNodes.size()); - final Collection> allDataChildren - = ((ContainerNode) rootNodes.iterator().next()).getValue(); + final Collection allDataChildren = ((ContainerNode) rootNodes.iterator().next()).body(); assertEquals(3, allDataChildren.size()); } - private static ContainerNode wrapNodeByDataRootContainer(final DataContainerChild data) { + private static ContainerNode wrapNodeByDataRootContainer(final DataContainerChild data) { return ImmutableContainerNodeBuilder.create() .withNodeIdentifier(NodeIdentifier.create(SchemaContext.NAME)) .withChild(data) @@ -272,35 +259,35 @@ public class RestconfDataServiceImplTest { */ @Test public void testReadDataMountPoint() { - doReturn(new MultivaluedHashMap()).when(this.uriInfo).getQueryParameters(); - doReturn(immediateFluentFuture(Optional.of(this.buildBaseContConfig))).when(this.read) - .read(LogicalDatastoreType.CONFIGURATION, this.iidBase); - doReturn(immediateFluentFuture(Optional.of(this.buildBaseContOperational))).when(this.read) - .read(LogicalDatastoreType.OPERATIONAL, this.iidBase); + doReturn(new MultivaluedHashMap()).when(uriInfo).getQueryParameters(); + doReturn(immediateFluentFuture(Optional.of(buildBaseContConfig))).when(read) + .read(LogicalDatastoreType.CONFIGURATION, iidBase); + doReturn(immediateFluentFuture(Optional.of(buildBaseContOperational))).when(read) + .read(LogicalDatastoreType.OPERATIONAL, iidBase); - final Response response = this.dataService.readData( - "example-jukebox:jukebox/yang-ext:mount/example-jukebox:jukebox", this.uriInfo); + final Response response = dataService.readData( + "example-jukebox:jukebox/yang-ext:mount/example-jukebox:jukebox", uriInfo); assertNotNull(response); assertEquals(200, response.getStatus()); // response must contain all child nodes from config and operational containers merged in one container - final NormalizedNode data = ((NormalizedNodeContext) response.getEntity()).getData(); + final NormalizedNode data = ((NormalizedNodePayload) response.getEntity()).getData(); assertTrue(data instanceof ContainerNode); - assertEquals(3, ((ContainerNode) data).getValue().size()); - assertTrue(((ContainerNode) data).getChild(this.buildPlayerCont.getIdentifier()).isPresent()); - assertTrue(((ContainerNode) data).getChild(this.buildLibraryCont.getIdentifier()).isPresent()); - assertTrue(((ContainerNode) data).getChild(this.buildPlaylistList.getIdentifier()).isPresent()); + assertEquals(3, ((ContainerNode) data).size()); + assertTrue(((ContainerNode) data).findChildByArg(buildPlayerCont.getIdentifier()).isPresent()); + assertTrue(((ContainerNode) data).findChildByArg(buildLibraryCont.getIdentifier()).isPresent()); + assertTrue(((ContainerNode) data).findChildByArg(buildPlaylistList.getIdentifier()).isPresent()); } @Test(expected = RestconfDocumentedException.class) public void testReadDataNoData() { - doReturn(new MultivaluedHashMap()).when(this.uriInfo).getQueryParameters(); + doReturn(new MultivaluedHashMap()).when(uriInfo).getQueryParameters(); doReturn(immediateFluentFuture(Optional.empty())) - .when(this.read).read(LogicalDatastoreType.CONFIGURATION, this.iidBase); + .when(read).read(LogicalDatastoreType.CONFIGURATION, iidBase); doReturn(immediateFluentFuture(Optional.empty())) - .when(this.read).read(LogicalDatastoreType.OPERATIONAL, this.iidBase); - this.dataService.readData("example-jukebox:jukebox", this.uriInfo); + .when(read).read(LogicalDatastoreType.OPERATIONAL, iidBase); + dataService.readData("example-jukebox:jukebox", uriInfo); } /** @@ -309,28 +296,26 @@ public class RestconfDataServiceImplTest { @Test public void testReadDataConfigTest() { final MultivaluedHashMap parameters = new MultivaluedHashMap<>(); - parameters.put("content", Collections.singletonList("config")); + parameters.put("content", List.of("config")); - doReturn(parameters).when(this.uriInfo).getQueryParameters(); - doReturn(immediateFluentFuture(Optional.of(this.buildBaseContConfig))).when(this.read) - .read(LogicalDatastoreType.CONFIGURATION, this.iidBase); - doReturn(immediateFluentFuture(Optional.of(this.buildBaseContOperational))).when(this.read) - .read(LogicalDatastoreType.OPERATIONAL, this.iidBase); + doReturn(parameters).when(uriInfo).getQueryParameters(); + doReturn(immediateFluentFuture(Optional.of(buildBaseContConfig))).when(read) + .read(LogicalDatastoreType.CONFIGURATION, iidBase); - final Response response = this.dataService.readData("example-jukebox:jukebox", this.uriInfo); + final Response response = dataService.readData("example-jukebox:jukebox", uriInfo); assertNotNull(response); assertEquals(200, response.getStatus()); // response must contain only config data - final NormalizedNode data = ((NormalizedNodeContext) response.getEntity()).getData(); + final NormalizedNode data = ((NormalizedNodePayload) response.getEntity()).getData(); // config data present - assertTrue(((ContainerNode) data).getChild(this.buildPlayerCont.getIdentifier()).isPresent()); - assertTrue(((ContainerNode) data).getChild(this.buildLibraryCont.getIdentifier()).isPresent()); + assertTrue(((ContainerNode) data).findChildByArg(buildPlayerCont.getIdentifier()).isPresent()); + assertTrue(((ContainerNode) data).findChildByArg(buildLibraryCont.getIdentifier()).isPresent()); // state data absent - assertFalse(((ContainerNode) data).getChild(this.buildPlaylistList.getIdentifier()).isPresent()); + assertFalse(((ContainerNode) data).findChildByArg(buildPlaylistList.getIdentifier()).isPresent()); } /** @@ -339,112 +324,94 @@ public class RestconfDataServiceImplTest { @Test public void testReadDataOperationalTest() { final MultivaluedHashMap parameters = new MultivaluedHashMap<>(); - parameters.put("content", Collections.singletonList("nonconfig")); + parameters.put("content", List.of("nonconfig")); - doReturn(parameters).when(this.uriInfo).getQueryParameters(); - doReturn(immediateFluentFuture(Optional.of(this.buildBaseContConfig))).when(this.read) - .read(LogicalDatastoreType.CONFIGURATION, this.iidBase); - doReturn(immediateFluentFuture(Optional.of(this.buildBaseContOperational))).when(this.read) - .read(LogicalDatastoreType.OPERATIONAL, this.iidBase); + doReturn(parameters).when(uriInfo).getQueryParameters(); + doReturn(immediateFluentFuture(Optional.of(buildBaseContOperational))).when(read) + .read(LogicalDatastoreType.OPERATIONAL, iidBase); - final Response response = this.dataService.readData("example-jukebox:jukebox", this.uriInfo); + final Response response = dataService.readData("example-jukebox:jukebox", uriInfo); assertNotNull(response); assertEquals(200, response.getStatus()); // response must contain only operational data - final NormalizedNode data = ((NormalizedNodeContext) response.getEntity()).getData(); + final NormalizedNode data = ((NormalizedNodePayload) response.getEntity()).getData(); // state data present - assertTrue(((ContainerNode) data).getChild(this.buildPlayerCont.getIdentifier()).isPresent()); - assertTrue(((ContainerNode) data).getChild(this.buildPlaylistList.getIdentifier()).isPresent()); + assertTrue(((ContainerNode) data).findChildByArg(buildPlayerCont.getIdentifier()).isPresent()); + assertTrue(((ContainerNode) data).findChildByArg(buildPlaylistList.getIdentifier()).isPresent()); // config data absent - assertFalse(((ContainerNode) data).getChild(this.buildLibraryCont.getIdentifier()).isPresent()); + assertFalse(((ContainerNode) data).findChildByArg(buildLibraryCont.getIdentifier()).isPresent()); } @Test public void testPutData() { - final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iidBase, this.schemaNode, null, this.contextRef); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseCont); - - doReturn(immediateTrueFluentFuture()).when(this.readWrite) - .exists(LogicalDatastoreType.CONFIGURATION, this.iidBase); - doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, this.iidBase, payload.getData()); - final Response response = this.dataService.putData(null, payload, this.uriInfo); + final InstanceIdentifierContext iidContext = + new InstanceIdentifierContext(iidBase, schemaNode, null, contextRef); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseCont); + + doReturn(immediateTrueFluentFuture()).when(read) + .exists(LogicalDatastoreType.CONFIGURATION, iidBase); + doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, iidBase, payload.getData()); + final Response response = dataService.putData(null, payload, uriInfo); assertNotNull(response); assertEquals(Response.Status.NO_CONTENT.getStatusCode(), response.getStatus()); } @Test public void testPutDataWithMountPoint() { -// final DOMDataBroker dataBroker = Mockito.mock(DOMDataBroker.class); -// doReturn(Optional.of(dataBroker)).when(mountPoint).getService(DOMDataBroker.class); -// doReturn(this.transactionChainHandler.get()).when(dataBroker) -// .createTransactionChain(RestConnectorProvider.TRANSACTION_CHAIN_LISTENER); - final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iidBase, this.schemaNode, mountPoint, this.contextRef); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseCont); - - doReturn(immediateTrueFluentFuture()).when(this.readWrite) - .exists(LogicalDatastoreType.CONFIGURATION, this.iidBase); - doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, this.iidBase, payload.getData()); - final Response response = this.dataService.putData(null, payload, this.uriInfo); + final InstanceIdentifierContext iidContext = + new InstanceIdentifierContext(iidBase, schemaNode, mountPoint, contextRef); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseCont); + + doReturn(immediateTrueFluentFuture()).when(read) + .exists(LogicalDatastoreType.CONFIGURATION, iidBase); + doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, iidBase, payload.getData()); + final Response response = dataService.putData(null, payload, uriInfo); assertNotNull(response); assertEquals(Response.Status.NO_CONTENT.getStatusCode(), response.getStatus()); } @Test public void testPostData() { - final QName listQname = QName.create(this.baseQName, "playlist"); - final QName listKeyQname = QName.create(this.baseQName, "name"); + final QName listQname = QName.create(baseQName, "playlist"); + final QName listKeyQname = QName.create(baseQName, "name"); final NodeIdentifierWithPredicates nodeWithKey = NodeIdentifierWithPredicates.of(listQname, listKeyQname, "name of band"); - final LeafNode content = Builders.leafBuilder() - .withNodeIdentifier(new NodeIdentifier(QName.create(this.baseQName, "name"))) - .withValue("name of band") - .build(); - final LeafNode content2 = Builders.leafBuilder() - .withNodeIdentifier(new NodeIdentifier(QName.create(this.baseQName, "description"))) - .withValue("band description") - .build(); - final MapEntryNode mapEntryNode = Builders.mapEntryBuilder() - .withNodeIdentifier(nodeWithKey) - .withChild(content) - .withChild(content2) - .build(); - final MapNode buildList = Builders.mapBuilder() - .withNodeIdentifier(new NodeIdentifier(listQname)) - .withChild(mapEntryNode) - .build(); - doReturn(new MultivaluedHashMap()).when(this.uriInfo).getQueryParameters(); - final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iidBase, null, null, this.contextRef); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, buildList); - doReturn(immediateFluentFuture(Optional.empty())) - .when(this.read).read(LogicalDatastoreType.CONFIGURATION, this.iidBase); + doReturn(new MultivaluedHashMap()).when(uriInfo).getQueryParameters(); + final InstanceIdentifierContext iidContext = + new InstanceIdentifierContext(iidBase, null, null, contextRef); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, Builders.mapBuilder() + .withNodeIdentifier(new NodeIdentifier(listQname)) + .withChild(Builders.mapEntryBuilder() + .withNodeIdentifier(nodeWithKey) + .withChild(ImmutableNodes.leafNode(QName.create(baseQName, "name"), "name of band")) + .withChild(ImmutableNodes.leafNode(QName.create(baseQName, "description"), "band description")) + .build()) + .build()); final MapNode data = (MapNode) payload.getData(); - final NodeIdentifierWithPredicates identifier = - data.getValue().iterator().next().getIdentifier(); + final MapEntryNode entryNode = data.body().iterator().next(); + final NodeIdentifierWithPredicates identifier = entryNode.getIdentifier(); final YangInstanceIdentifier node = payload.getInstanceIdentifierContext().getInstanceIdentifier().node(identifier); doReturn(immediateFalseFluentFuture()) - .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, node); - doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, node, payload.getData()); - doReturn(UriBuilder.fromUri("http://localhost:8181/restconf/15/")).when(this.uriInfo).getBaseUriBuilder(); + .when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, node); + doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, node, entryNode); + doReturn(UriBuilder.fromUri("http://localhost:8181/restconf/15/")).when(uriInfo).getBaseUriBuilder(); - final Response response = this.dataService.postData(null, payload, this.uriInfo); + final Response response = dataService.postData(null, payload, uriInfo); assertEquals(201, response.getStatus()); } @Test public void testDeleteData() { - doNothing().when(this.readWrite).delete(LogicalDatastoreType.CONFIGURATION, this.iidBase); + doNothing().when(readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidBase); doReturn(immediateTrueFluentFuture()) - .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iidBase); - final Response response = this.dataService.deleteData("example-jukebox:jukebox"); + .when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidBase); + final Response response = dataService.deleteData("example-jukebox:jukebox"); assertNotNull(response); assertEquals(Response.Status.NO_CONTENT.getStatusCode(), response.getStatus()); } @@ -454,38 +421,35 @@ public class RestconfDataServiceImplTest { */ @Test public void testDeleteDataMountPoint() { - doNothing().when(this.readWrite).delete(LogicalDatastoreType.CONFIGURATION, this.iidBase); + doNothing().when(readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidBase); doReturn(immediateTrueFluentFuture()) - .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iidBase); + .when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidBase); final Response response = - this.dataService.deleteData("example-jukebox:jukebox/yang-ext:mount/example-jukebox:jukebox"); + dataService.deleteData("example-jukebox:jukebox/yang-ext:mount/example-jukebox:jukebox"); assertNotNull(response); assertEquals(Response.Status.NO_CONTENT.getStatusCode(), response.getStatus()); } @Test - public void testPatchData() throws Exception { - final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iidBase, this.schemaNode, null, this.contextRef); + public void testPatchData() { + final InstanceIdentifierContext iidContext = + new InstanceIdentifierContext(iidBase, schemaNode, null, contextRef); final List entity = new ArrayList<>(); - final YangInstanceIdentifier iidleaf = YangInstanceIdentifier.builder(this.iidBase) - .node(this.containerPlayerQname) - .node(this.leafQname) + final YangInstanceIdentifier iidleaf = YangInstanceIdentifier.builder(iidBase) + .node(containerPlayerQname) + .node(leafQname) .build(); - entity.add(new PatchEntity("create data", CREATE, this.iidBase, this.buildBaseCont)); - entity.add(new PatchEntity("replace data", REPLACE, this.iidBase, this.buildBaseCont)); + entity.add(new PatchEntity("create data", CREATE, iidBase, buildBaseCont)); + entity.add(new PatchEntity("replace data", REPLACE, iidBase, buildBaseCont)); entity.add(new PatchEntity("delete data", DELETE, iidleaf)); final PatchContext patch = new PatchContext(iidContext, entity, "test patch id"); - doReturn(immediateFluentFuture(Optional.of(this.buildBaseCont))).when(this.read) - .read(LogicalDatastoreType.CONFIGURATION, this.iidBase); - doNothing().when(this.write).put(LogicalDatastoreType.CONFIGURATION, this.iidBase, this.buildBaseCont); - doNothing().when(this.readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidleaf); + doNothing().when(readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidleaf); doReturn(immediateFalseFluentFuture()) - .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iidBase); + .when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidBase); doReturn(immediateTrueFluentFuture()) - .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidleaf); - final PatchStatusContext status = this.dataService.patchData(patch, this.uriInfo); + .when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidleaf); + final PatchStatusContext status = dataService.patchData(patch, uriInfo); assertTrue(status.isOk()); assertEquals(3, status.getEditCollection().size()); assertEquals("replace data", status.getEditCollection().get(1).getEditId()); @@ -493,56 +457,50 @@ public class RestconfDataServiceImplTest { @Test public void testPatchDataMountPoint() throws Exception { - final InstanceIdentifierContext iidContext = new InstanceIdentifierContext<>( - this.iidBase, this.schemaNode, this.mountPoint, this.contextRef); + final InstanceIdentifierContext iidContext = new InstanceIdentifierContext( + iidBase, schemaNode, mountPoint, contextRef); final List entity = new ArrayList<>(); - final YangInstanceIdentifier iidleaf = YangInstanceIdentifier.builder(this.iidBase) - .node(this.containerPlayerQname) - .node(this.leafQname) + final YangInstanceIdentifier iidleaf = YangInstanceIdentifier.builder(iidBase) + .node(containerPlayerQname) + .node(leafQname) .build(); - entity.add(new PatchEntity("create data", CREATE, this.iidBase, this.buildBaseCont)); - entity.add(new PatchEntity("replace data", REPLACE, this.iidBase, this.buildBaseCont)); + entity.add(new PatchEntity("create data", CREATE, iidBase, buildBaseCont)); + entity.add(new PatchEntity("replace data", REPLACE, iidBase, buildBaseCont)); entity.add(new PatchEntity("delete data", DELETE, iidleaf)); final PatchContext patch = new PatchContext(iidContext, entity, "test patch id"); - doReturn(immediateFluentFuture(Optional.of(this.buildBaseCont))).when(this.read) - .read(LogicalDatastoreType.CONFIGURATION, this.iidBase); - doNothing().when(this.write).put(LogicalDatastoreType.CONFIGURATION, this.iidBase, this.buildBaseCont); - doNothing().when(this.readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidleaf); + doNothing().when(readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidleaf); doReturn(immediateFalseFluentFuture()) - .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iidBase); - doReturn(immediateTrueFluentFuture()).when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidleaf); + .when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidBase); + doReturn(immediateTrueFluentFuture()).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidleaf); - final PatchStatusContext status = this.dataService.patchData(patch, this.uriInfo); + final PatchStatusContext status = dataService.patchData(patch, uriInfo); assertTrue(status.isOk()); assertEquals(3, status.getEditCollection().size()); assertNull(status.getGlobalErrors()); } @Test - public void testPatchDataDeleteNotExist() throws Exception { - final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iidBase, this.schemaNode, null, this.contextRef); + public void testPatchDataDeleteNotExist() { + final InstanceIdentifierContext iidContext = + new InstanceIdentifierContext(iidBase, schemaNode, null, contextRef); final List entity = new ArrayList<>(); - final YangInstanceIdentifier iidleaf = YangInstanceIdentifier.builder(this.iidBase) - .node(this.containerPlayerQname) - .node(this.leafQname) + final YangInstanceIdentifier iidleaf = YangInstanceIdentifier.builder(iidBase) + .node(containerPlayerQname) + .node(leafQname) .build(); - entity.add(new PatchEntity("create data", CREATE, this.iidBase, this.buildBaseCont)); + entity.add(new PatchEntity("create data", CREATE, iidBase, buildBaseCont)); entity.add(new PatchEntity("remove data", REMOVE, iidleaf)); entity.add(new PatchEntity("delete data", DELETE, iidleaf)); final PatchContext patch = new PatchContext(iidContext, entity, "test patch id"); - doReturn(immediateFluentFuture(Optional.of(this.buildBaseCont))).when(this.read) - .read(LogicalDatastoreType.CONFIGURATION, this.iidBase); - doNothing().when(this.write).put(LogicalDatastoreType.CONFIGURATION, this.iidBase, this.buildBaseCont); - doNothing().when(this.readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidleaf); + doNothing().when(readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidleaf); doReturn(immediateFalseFluentFuture()) - .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iidBase); + .when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidBase); doReturn(immediateFalseFluentFuture()) - .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidleaf); - doReturn(true).when(this.readWrite).cancel(); - final PatchStatusContext status = this.dataService.patchData(patch, this.uriInfo); + .when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidleaf); + doReturn(true).when(readWrite).cancel(); + final PatchStatusContext status = dataService.patchData(patch, uriInfo); assertFalse(status.isOk()); assertEquals(3, status.getEditCollection().size()); @@ -556,14 +514,11 @@ public class RestconfDataServiceImplTest { @Test public void testGetRestconfStrategy() { - final InstanceIdentifierContext iidContext = new InstanceIdentifierContext<>( - this.iidBase, this.schemaNode, this.mountPoint, this.contextRef); - - RestconfStrategy restconfStrategy = this.dataService.getRestconfStrategy(iidContext, this.mountPoint); + RestconfStrategy restconfStrategy = dataService.getRestconfStrategy(mountPoint); assertTrue(restconfStrategy instanceof MdsalRestconfStrategy); - doReturn(Optional.of(this.netconfService)).when(this.mountPoint).getService(NetconfDataTreeService.class); - restconfStrategy = this.dataService.getRestconfStrategy(iidContext, this.mountPoint); + doReturn(Optional.of(netconfService)).when(mountPoint).getService(NetconfDataTreeService.class); + restconfStrategy = dataService.getRestconfStrategy(mountPoint); assertTrue(restconfStrategy instanceof NetconfRestconfStrategy); } }