From 6aa01b1c2105b8e54e667e8b85e06775889527d6 Mon Sep 17 00:00:00 2001 From: Robert Varga Date: Sat, 23 Oct 2021 14:20:55 +0200 Subject: [PATCH] Split out RFC8040-only constructs from yang-common We have a number of constructs dropped in restconf-common, which are only relevant to RFC8040. Refactor code so that we do not constrained by restconf-common when we refactor the wiring. JIRA: NETCONF-773 Change-Id: Ie457307ad1ab239fdf70ba06654e3ab4c6090aa6 Signed-off-by: Robert Varga --- .../common/context/WriterParameters.java | 57 +--- .../common/util/OperationsResourceUtils.java | 11 +- .../sal/restconf/impl/RestconfImpl.java | 3 +- .../AbstractNormalizedNodeBodyReader.java | 10 +- .../AbstractNormalizedNodeBodyWriter.java | 6 +- .../JsonNormalizedNodeBodyReader.java | 9 +- .../JsonNormalizedNodeBodyWriter.java | 4 +- .../XmlNormalizedNodeBodyReader.java | 9 +- .../XmlNormalizedNodeBodyWriter.java | 4 +- .../rfc8040/legacy/NormalizedNodePayload.java | 59 ++++ .../nb/rfc8040/legacy/QueryParameters.java | 97 ++++++ .../nb/rfc8040/legacy/package-info.java | 17 + .../services/api/RestconfDataService.java | 14 +- .../api/RestconfInvokeOperationsService.java | 8 +- .../api/RestconfOperationsService.java | 6 +- .../rests/services/api/RestconfService.java | 6 +- .../RestconfStreamsSubscriptionService.java | 6 +- .../impl/RestconfDataServiceImpl.java | 13 +- .../rests/services/impl/RestconfImpl.java | 6 +- .../RestconfInvokeOperationsServiceImpl.java | 3 +- .../impl/RestconfOperationsServiceImpl.java | 7 +- ...estconfStreamsSubscriptionServiceImpl.java | 10 +- .../utils/PlainPatchDataTransactionUtil.java | 4 +- .../rests/utils/PostDataTransactionUtil.java | 4 +- .../rests/utils/PutDataTransactionUtil.java | 4 +- .../rests/utils/ReadDataTransactionUtil.java | 9 +- .../impl/RestconfDataServiceImplTest.java | 306 +++++++++--------- ...stconfInvokeOperationsServiceImplTest.java | 9 +- .../PlainPatchDataTransactionUtilTest.java | 88 ++--- .../utils/PostDataTransactionUtilTest.java | 112 +++---- .../utils/PutDataTransactionUtilTest.java | 225 ++++++------- .../utils/ReadDataTransactionUtilTest.java | 56 ++-- 32 files changed, 650 insertions(+), 532 deletions(-) create mode 100644 restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/legacy/NormalizedNodePayload.java create mode 100644 restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/legacy/QueryParameters.java create mode 100644 restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/legacy/package-info.java diff --git a/restconf/restconf-common/src/main/java/org/opendaylight/restconf/common/context/WriterParameters.java b/restconf/restconf-common/src/main/java/org/opendaylight/restconf/common/context/WriterParameters.java index 03958b8587..aca8c5f43a 100644 --- a/restconf/restconf-common/src/main/java/org/opendaylight/restconf/common/context/WriterParameters.java +++ b/restconf/restconf-common/src/main/java/org/opendaylight/restconf/common/context/WriterParameters.java @@ -7,48 +7,23 @@ */ package org.opendaylight.restconf.common.context; -import java.util.List; -import java.util.Set; -import org.opendaylight.yangtools.yang.common.QName; -import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; - -public final class WriterParameters { +public class WriterParameters { static final WriterParameters EMPTY = new WriterParametersBuilder().build(); - private final String content; private final Integer depth; - private final List> fields; - private final List fieldPaths; private final boolean prettyPrint; private final boolean tagged; - private final String withDefault; - private WriterParameters(final WriterParametersBuilder builder) { - content = builder.content; + protected WriterParameters(final WriterParametersBuilder builder) { depth = builder.depth; - fields = builder.fields; - fieldPaths = builder.fieldPaths; prettyPrint = builder.prettyPrint; tagged = builder.tagged; - withDefault = builder.withDefault; - } - - public String getContent() { - return content; } public Integer getDepth() { return depth; } - public List> getFields() { - return fields; - } - - public List getFieldPaths() { - return fieldPaths; - } - public boolean isPrettyPrint() { return prettyPrint; } @@ -57,53 +32,25 @@ public final class WriterParameters { return tagged; } - public String getWithDefault() { - return withDefault; - } - public static class WriterParametersBuilder { - private String content; private Integer depth; - private List> fields; - private List fieldPaths; private boolean prettyPrint; private boolean tagged; - private String withDefault; public WriterParametersBuilder() { } - public WriterParametersBuilder setContent(final String content) { - this.content = content; - return this; - } - public WriterParametersBuilder setDepth(final int depth) { this.depth = depth; return this; } - public WriterParametersBuilder setFields(final List> fields) { - this.fields = fields; - return this; - } - - public WriterParametersBuilder setFieldPaths(final List fieldPaths) { - this.fieldPaths = fieldPaths; - return this; - } - public WriterParametersBuilder setPrettyPrint(final boolean prettyPrint) { this.prettyPrint = prettyPrint; return this; } - public WriterParametersBuilder setWithDefault(final String withDefault) { - this.withDefault = withDefault; - return this; - } - public WriterParameters build() { return new WriterParameters(this); } diff --git a/restconf/restconf-common/src/main/java/org/opendaylight/restconf/common/util/OperationsResourceUtils.java b/restconf/restconf-common/src/main/java/org/opendaylight/restconf/common/util/OperationsResourceUtils.java index 362f4c29f5..03e289d19e 100644 --- a/restconf/restconf-common/src/main/java/org/opendaylight/restconf/common/util/OperationsResourceUtils.java +++ b/restconf/restconf-common/src/main/java/org/opendaylight/restconf/common/util/OperationsResourceUtils.java @@ -10,11 +10,12 @@ package org.opendaylight.restconf.common.util; import com.google.common.collect.ImmutableSet; import java.util.ArrayList; import java.util.Collection; +import java.util.Map; +import java.util.Map.Entry; import org.eclipse.jdt.annotation.NonNull; import org.eclipse.jdt.annotation.Nullable; import org.opendaylight.mdsal.dom.api.DOMMountPoint; import org.opendaylight.restconf.common.context.InstanceIdentifierContext; -import org.opendaylight.restconf.common.context.NormalizedNodeContext; import org.opendaylight.yangtools.yang.common.Empty; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode; @@ -32,8 +33,8 @@ public final class OperationsResourceUtils { // Hidden on purpose } - public static @NonNull NormalizedNodeContext contextForModelContext(final @NonNull SchemaContext context, - final @Nullable DOMMountPoint mountPoint) { + public static @NonNull Entry, ContainerNode> + contextForModelContext(final @NonNull SchemaContext context, final @Nullable DOMMountPoint mountPoint) { // Determine which modules we need and construct leaf schemas to correspond to all RPC definitions final Collection modules = new ArrayList<>(); final ArrayList rpcLeafSchemas = new ArrayList<>(); @@ -59,7 +60,7 @@ public final class OperationsResourceUtils { operationsBuilder.withChild(ImmutableNodes.leafNode(leaf.getQName(), Empty.getInstance())); } - return new NormalizedNodeContext(new InstanceIdentifierContext<>(null, operatationsSchema, mountPoint, - new OperationsEffectiveModuleContext(ImmutableSet.copyOf(modules))), operationsBuilder.build()); + return Map.entry(new InstanceIdentifierContext<>(null, operatationsSchema, mountPoint, + new OperationsEffectiveModuleContext(ImmutableSet.copyOf(modules))), operationsBuilder.build()); } } diff --git a/restconf/restconf-nb-bierman02/src/main/java/org/opendaylight/netconf/sal/restconf/impl/RestconfImpl.java b/restconf/restconf-nb-bierman02/src/main/java/org/opendaylight/netconf/sal/restconf/impl/RestconfImpl.java index 54891164e7..ba7195daab 100644 --- a/restconf/restconf-nb-bierman02/src/main/java/org/opendaylight/netconf/sal/restconf/impl/RestconfImpl.java +++ b/restconf/restconf-nb-bierman02/src/main/java/org/opendaylight/netconf/sal/restconf/impl/RestconfImpl.java @@ -352,7 +352,8 @@ public final class RestconfImpl implements RestconfService { final InstanceIdentifierContext mountPointIdentifier = controllerContext.toMountPointIdentifier(identifier); final DOMMountPoint mountPoint = mountPointIdentifier.getMountPoint(); - return OperationsResourceUtils.contextForModelContext(modelContext(mountPoint), mountPoint); + final var entry = OperationsResourceUtils.contextForModelContext(modelContext(mountPoint), mountPoint); + return new NormalizedNodeContext(entry.getKey(), entry.getValue()); } private Module getRestconfModule() { diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/AbstractNormalizedNodeBodyReader.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/AbstractNormalizedNodeBodyReader.java index 78d1d1d0a4..37939742c3 100644 --- a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/AbstractNormalizedNodeBodyReader.java +++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/AbstractNormalizedNodeBodyReader.java @@ -11,14 +11,14 @@ import javax.ws.rs.core.Request; import javax.ws.rs.core.UriInfo; import org.opendaylight.mdsal.dom.api.DOMMountPointService; import org.opendaylight.restconf.common.context.InstanceIdentifierContext; -import org.opendaylight.restconf.common.context.NormalizedNodeContext; import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler; import org.opendaylight.restconf.nb.rfc8040.jersey.providers.spi.AbstractIdentifierAwareJaxRsProvider; +import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload; /** - * Common superclass for readers producing {@link NormalizedNodeContext}. + * Common superclass for readers producing {@link NormalizedNodePayload}. */ -abstract class AbstractNormalizedNodeBodyReader extends AbstractIdentifierAwareJaxRsProvider { +abstract class AbstractNormalizedNodeBodyReader extends AbstractIdentifierAwareJaxRsProvider { AbstractNormalizedNodeBodyReader(final SchemaContextHandler schemaContextHandler, final DOMMountPointService mountPointService) { super(schemaContextHandler, mountPointService); @@ -30,7 +30,7 @@ abstract class AbstractNormalizedNodeBodyReader extends AbstractIdentifierAwareJ } @Override - protected final NormalizedNodeContext emptyBody(final InstanceIdentifierContext path) { - return new NormalizedNodeContext(path, null); + protected final NormalizedNodePayload emptyBody(final InstanceIdentifierContext path) { + return NormalizedNodePayload.empty(path); } } diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/AbstractNormalizedNodeBodyWriter.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/AbstractNormalizedNodeBodyWriter.java index 893c94e8f6..fcdd638ee2 100644 --- a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/AbstractNormalizedNodeBodyWriter.java +++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/AbstractNormalizedNodeBodyWriter.java @@ -11,12 +11,12 @@ import java.lang.annotation.Annotation; import java.lang.reflect.Type; import javax.ws.rs.core.MediaType; import javax.ws.rs.ext.MessageBodyWriter; -import org.opendaylight.restconf.common.context.NormalizedNodeContext; +import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload; -abstract class AbstractNormalizedNodeBodyWriter implements MessageBodyWriter { +abstract class AbstractNormalizedNodeBodyWriter implements MessageBodyWriter { @Override public final boolean isWriteable(final Class type, final Type genericType, final Annotation[] annotations, final MediaType mediaType) { - return type.equals(NormalizedNodeContext.class); + return type.equals(NormalizedNodePayload.class); } } diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/JsonNormalizedNodeBodyReader.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/JsonNormalizedNodeBodyReader.java index e5574facdb..d462ffadfd 100644 --- a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/JsonNormalizedNodeBodyReader.java +++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/JsonNormalizedNodeBodyReader.java @@ -22,10 +22,10 @@ import javax.ws.rs.ext.Provider; import org.eclipse.jdt.annotation.NonNull; import org.opendaylight.mdsal.dom.api.DOMMountPointService; 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.MediaTypes; import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler; +import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload; import org.opendaylight.yangtools.yang.common.ErrorTag; import org.opendaylight.yangtools.yang.common.ErrorType; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; @@ -63,7 +63,7 @@ public class JsonNormalizedNodeBodyReader extends AbstractNormalizedNodeBodyRead @SuppressWarnings("checkstyle:IllegalCatch") @Override - protected NormalizedNodeContext readBody(final InstanceIdentifierContext path, final InputStream entityStream) + protected NormalizedNodePayload readBody(final InstanceIdentifierContext path, final InputStream entityStream) throws WebApplicationException { try { return readFrom(path, entityStream, isPost()); @@ -73,7 +73,7 @@ public class JsonNormalizedNodeBodyReader extends AbstractNormalizedNodeBodyRead } } - public static NormalizedNodeContext readFrom( + public static NormalizedNodePayload readFrom( final InstanceIdentifierContext path, final InputStream entityStream, final boolean isPost) { final NormalizedNodeResult resultHolder = new NormalizedNodeResult(); final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder); @@ -130,7 +130,8 @@ public class JsonNormalizedNodeBodyReader extends AbstractNormalizedNodeBodyRead newIIContext = new InstanceIdentifierContext<>(fullIIToData, path.getSchemaNode(), path.getMountPoint(), path.getSchemaContext()); - return new NormalizedNodeContext(newIIContext, result); + // FIXME: can result really be null? + return NormalizedNodePayload.ofNullable(newIIContext, result); } private static void propagateExceptionAs(final Exception exception) throws RestconfDocumentedException { diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/JsonNormalizedNodeBodyWriter.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/JsonNormalizedNodeBodyWriter.java index 585bcc7db1..51eab9c83e 100644 --- a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/JsonNormalizedNodeBodyWriter.java +++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/JsonNormalizedNodeBodyWriter.java @@ -23,9 +23,9 @@ import javax.ws.rs.core.MediaType; import javax.ws.rs.core.MultivaluedMap; import javax.ws.rs.ext.Provider; import org.opendaylight.restconf.common.context.InstanceIdentifierContext; -import org.opendaylight.restconf.common.context.NormalizedNodeContext; import org.opendaylight.restconf.nb.rfc8040.MediaTypes; import org.opendaylight.restconf.nb.rfc8040.jersey.providers.api.RestconfNormalizedNodeWriter; +import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.common.XMLNamespace; import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode; @@ -50,7 +50,7 @@ public class JsonNormalizedNodeBodyWriter extends AbstractNormalizedNodeBodyWrit private static final int DEFAULT_INDENT_SPACES_NUM = 2; @Override - public void writeTo(final NormalizedNodeContext context, + public void writeTo(final NormalizedNodePayload context, final Class type, final Type genericType, final Annotation[] annotations, diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/XmlNormalizedNodeBodyReader.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/XmlNormalizedNodeBodyReader.java index 41ef125f2d..b26bbd47dc 100644 --- a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/XmlNormalizedNodeBodyReader.java +++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/XmlNormalizedNodeBodyReader.java @@ -26,10 +26,10 @@ import javax.xml.stream.XMLStreamException; import javax.xml.transform.dom.DOMSource; import org.opendaylight.mdsal.dom.api.DOMMountPointService; 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.MediaTypes; import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler; +import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload; import org.opendaylight.yangtools.util.xml.UntrustedXML; import org.opendaylight.yangtools.yang.common.ErrorTag; import org.opendaylight.yangtools.yang.common.ErrorType; @@ -71,7 +71,7 @@ public class XmlNormalizedNodeBodyReader extends AbstractNormalizedNodeBodyReade @SuppressWarnings("checkstyle:IllegalCatch") @Override - protected NormalizedNodeContext readBody(final InstanceIdentifierContext path, final InputStream entityStream) + protected NormalizedNodePayload readBody(final InstanceIdentifierContext path, final InputStream entityStream) throws WebApplicationException { try { final Document doc = UntrustedXML.newDocumentBuilder().parse(entityStream); @@ -86,7 +86,7 @@ public class XmlNormalizedNodeBodyReader extends AbstractNormalizedNodeBodyReade } } - private NormalizedNodeContext parse(final InstanceIdentifierContext pathContext, final Document doc) + private NormalizedNodePayload parse(final InstanceIdentifierContext pathContext, final Document doc) throws XMLStreamException, IOException, ParserConfigurationException, SAXException, URISyntaxException { final SchemaNode schemaNodeContext = pathContext.getSchemaNode(); DataSchemaNode schemaNode; @@ -164,7 +164,8 @@ public class XmlNormalizedNodeBodyReader extends AbstractNormalizedNodeBodyReade final InstanceIdentifierContext outIIContext = new InstanceIdentifierContext<>( fullIIToData, pathContext.getSchemaNode(), pathContext.getMountPoint(), pathContext.getSchemaContext()); - return new NormalizedNodeContext(outIIContext, parsed); + // FIXME: can result really be null? + return NormalizedNodePayload.ofNullable(outIIContext, parsed); } private static Deque findPathToSchemaNodeByName(final DataSchemaNode schemaNode, final String elementName, diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/XmlNormalizedNodeBodyWriter.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/XmlNormalizedNodeBodyWriter.java index 621273142a..ac440b23bb 100644 --- a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/XmlNormalizedNodeBodyWriter.java +++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/XmlNormalizedNodeBodyWriter.java @@ -27,9 +27,9 @@ import javax.xml.stream.XMLOutputFactory; import javax.xml.stream.XMLStreamException; import javax.xml.stream.XMLStreamWriter; import org.opendaylight.restconf.common.context.InstanceIdentifierContext; -import org.opendaylight.restconf.common.context.NormalizedNodeContext; import org.opendaylight.restconf.nb.rfc8040.MediaTypes; import org.opendaylight.restconf.nb.rfc8040.jersey.providers.api.RestconfNormalizedNodeWriter; +import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode; import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode; @@ -53,7 +53,7 @@ public class XmlNormalizedNodeBodyWriter extends AbstractNormalizedNodeBodyWrite } @Override - public void writeTo(final NormalizedNodeContext context, + public void writeTo(final NormalizedNodePayload context, final Class type, final Type genericType, final Annotation[] annotations, diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/legacy/NormalizedNodePayload.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/legacy/NormalizedNodePayload.java new file mode 100644 index 0000000000..346e6e03a2 --- /dev/null +++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/legacy/NormalizedNodePayload.java @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2021 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.restconf.nb.rfc8040.legacy; + +import static java.util.Objects.requireNonNull; + +import com.google.common.collect.ImmutableMap; +import edu.umd.cs.findbugs.annotations.SuppressFBWarnings; +import java.net.URI; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.restconf.common.context.InstanceIdentifierContext; +import org.opendaylight.restconf.common.context.NormalizedNodeContext; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier; +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; +import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes; + +/** + * A RFC8040 overlay over {@link NormalizedNodeContext}. This represents a NormalizedNode along with further messy + * details needed to deal with the payload. + */ +public final class NormalizedNodePayload extends NormalizedNodeContext { + private NormalizedNodePayload(final InstanceIdentifierContext context, + final NormalizedNode data, final QueryParameters writerParameters, + final ImmutableMap headers) { + super(context, data, writerParameters, headers); + } + + public static @NonNull NormalizedNodePayload empty(final InstanceIdentifierContext path) { + return new NormalizedNodePayload(requireNonNull(path), null, QueryParameters.empty(), ImmutableMap.of()); + } + + public static @NonNull NormalizedNodePayload of(final InstanceIdentifierContext path, + final NormalizedNode data) { + return new NormalizedNodePayload(requireNonNull(path), requireNonNull(data), QueryParameters.empty(), + ImmutableMap.of()); + } + + public static @NonNull NormalizedNodePayload ofNullable(final InstanceIdentifierContext path, + final NormalizedNode data) { + return data == null ? empty(path) : of(path, data); + } + + public static @NonNull NormalizedNodePayload ofLocation(final InstanceIdentifierContext path, + final NodeIdentifier leafId, final URI location) { + return new NormalizedNodePayload(requireNonNull(path), ImmutableNodes.leafNode(leafId, location.toString()), + QueryParameters.empty(), ImmutableMap.of("Location", location)); + } + + @SuppressFBWarnings(value = "BC_UNCONFIRMED_CAST_OF_RETURN_VALUE", justification = "Ensured via constructor") + @Override + public QueryParameters getWriterParameters() { + return (QueryParameters) super.getWriterParameters(); + } +} diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/legacy/QueryParameters.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/legacy/QueryParameters.java new file mode 100644 index 0000000000..7fa4deb822 --- /dev/null +++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/legacy/QueryParameters.java @@ -0,0 +1,97 @@ +/* + * Copyright (c) 2021 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.restconf.nb.rfc8040.legacy; + +import java.util.List; +import java.util.Set; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.restconf.common.context.WriterParameters; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; + +/** + * A RFC8040 overlay over {@link WriterParameters}. This holds various options acquired from a requests's query part. + * This class needs to be further split up to make sense of it, as parts of it pertain to how a + * {@link NormalizedNodePayload} should be created while others how it needs to be processed (for example filtered). + */ +public final class QueryParameters extends WriterParameters { + public static final class Builder extends WriterParametersBuilder { + private List fieldPaths; + private List> fields; + private String withDefault; + private String content; + + Builder() { + // Hidden on purpose + } + + public Builder setContent(final String content) { + this.content = content; + return this; + } + + public Builder setFields(final List> fields) { + this.fields = fields; + return this; + } + + public Builder setFieldPaths(final List fieldPaths) { + this.fieldPaths = fieldPaths; + return this; + } + + public Builder setWithDefault(final String withDefault) { + this.withDefault = withDefault; + return this; + } + + @Override + public @NonNull QueryParameters build() { + return new QueryParameters(this); + } + } + + private static final @NonNull QueryParameters EMPTY = new Builder().build(); + + private final List fieldPaths; + private final List> fields; + private final String withDefault; + private final String content; + + private QueryParameters(final Builder builder) { + super(builder); + content = builder.content; + fields = builder.fields; + fieldPaths = builder.fieldPaths; + withDefault = builder.withDefault; + } + + public static @NonNull QueryParameters empty() { + return EMPTY; + } + + public static @NonNull Builder builder() { + return new Builder(); + } + + public String getContent() { + return content; + } + + public List> getFields() { + return fields; + } + + public List getFieldPaths() { + return fieldPaths; + } + + public String getWithDefault() { + return withDefault; + } +} diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/legacy/package-info.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/legacy/package-info.java new file mode 100644 index 0000000000..f077ed1ae7 --- /dev/null +++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/legacy/package-info.java @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2021 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +/** + * Various legacy constructs used in RFC8040 northbound. This package holds classes which are needed to properly extend + * restconf-common constructs without polluting them with things that are internal to this implementation and either are + * not or cannot be assumed to be relevant to bierman02. + * + *

+ * These constructs are subject to future removal as we restructure how RESTCONF requests are wired to JAX-RS, bound to + * the runtime environment (MD-SAL services and mount points). + */ +package org.opendaylight.restconf.nb.rfc8040.legacy; \ No newline at end of file diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/api/RestconfDataService.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/api/RestconfDataService.java index bd503bfbea..96dd9976f1 100644 --- a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/api/RestconfDataService.java +++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/api/RestconfDataService.java @@ -20,11 +20,11 @@ import javax.ws.rs.core.Context; import javax.ws.rs.core.MediaType; import javax.ws.rs.core.Response; import javax.ws.rs.core.UriInfo; -import org.opendaylight.restconf.common.context.NormalizedNodeContext; import org.opendaylight.restconf.common.patch.Patch; import org.opendaylight.restconf.common.patch.PatchContext; import org.opendaylight.restconf.common.patch.PatchStatusContext; import org.opendaylight.restconf.nb.rfc8040.MediaTypes; +import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload; /** * The "{+restconf}/data" subtree represents the datastore resource type, which @@ -39,7 +39,7 @@ public interface RestconfDataService { * path to target * @param uriInfo * URI info - * @return {@link NormalizedNodeContext} + * @return {@link NormalizedNodePayload} */ @GET @Path("/data/{identifier:.+}") @@ -57,7 +57,7 @@ public interface RestconfDataService { * * @param uriInfo * URI info - * @return {@link NormalizedNodeContext} + * @return {@link NormalizedNodePayload} */ @GET @Path("/data") @@ -88,7 +88,7 @@ public interface RestconfDataService { MediaType.APPLICATION_XML, MediaType.TEXT_XML }) - Response putData(@Encoded @PathParam("identifier") String identifier, NormalizedNodeContext payload, + Response putData(@Encoded @PathParam("identifier") String identifier, NormalizedNodePayload payload, @Context UriInfo uriInfo); /** @@ -111,7 +111,7 @@ public interface RestconfDataService { MediaType.APPLICATION_XML, MediaType.TEXT_XML }) - Response postData(@Encoded @PathParam("identifier") String identifier, NormalizedNodeContext payload, + Response postData(@Encoded @PathParam("identifier") String identifier, NormalizedNodePayload payload, @Context UriInfo uriInfo); /** @@ -132,7 +132,7 @@ public interface RestconfDataService { MediaType.APPLICATION_XML, MediaType.TEXT_XML }) - Response postData(NormalizedNodeContext payload, @Context UriInfo uriInfo); + Response postData(NormalizedNodePayload payload, @Context UriInfo uriInfo); /** * Delete the target data resource. @@ -210,6 +210,6 @@ public interface RestconfDataService { MediaType.APPLICATION_XML, MediaType.TEXT_XML }) - Response patchData(@Encoded @PathParam("identifier") String identifier, NormalizedNodeContext payload, + Response patchData(@Encoded @PathParam("identifier") String identifier, NormalizedNodePayload payload, @Context UriInfo uriInfo); } diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/api/RestconfInvokeOperationsService.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/api/RestconfInvokeOperationsService.java index e0db6a0f5e..31370aaf83 100644 --- a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/api/RestconfInvokeOperationsService.java +++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/api/RestconfInvokeOperationsService.java @@ -18,8 +18,8 @@ import javax.ws.rs.container.Suspended; import javax.ws.rs.core.Context; import javax.ws.rs.core.MediaType; import javax.ws.rs.core.UriInfo; -import org.opendaylight.restconf.common.context.NormalizedNodeContext; import org.opendaylight.restconf.nb.rfc8040.MediaTypes; +import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload; /** * An operation resource represents a protocol operation defined with the YANG {@code rpc} statement. It is invoked @@ -30,9 +30,9 @@ public interface RestconfInvokeOperationsService { * Invoke RPC operation. * * @param identifier module name and rpc identifier string for the desired operation - * @param payload {@link NormalizedNodeContext} - the body of the operation + * @param payload {@link NormalizedNodePayload} - the body of the operation * @param uriInfo URI info - * @param ar {@link AsyncResponse} which needs to be completed with a {@link NormalizedNodeContext} ouput + * @param ar {@link AsyncResponse} which needs to be completed with a {@link NormalizedNodePayload} output */ @POST @Path("/operations/{identifier:.+}") @@ -50,6 +50,6 @@ public interface RestconfInvokeOperationsService { MediaType.APPLICATION_XML, MediaType.TEXT_XML }) - void invokeRpc(@Encoded @PathParam("identifier") String identifier, NormalizedNodeContext payload, + void invokeRpc(@Encoded @PathParam("identifier") String identifier, NormalizedNodePayload payload, @Context UriInfo uriInfo, @Suspended AsyncResponse ar); } diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/api/RestconfOperationsService.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/api/RestconfOperationsService.java index 2a1a1a5bba..80c07d6aeb 100644 --- a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/api/RestconfOperationsService.java +++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/api/RestconfOperationsService.java @@ -14,8 +14,8 @@ import javax.ws.rs.Produces; import javax.ws.rs.core.Context; import javax.ws.rs.core.MediaType; import javax.ws.rs.core.UriInfo; -import org.opendaylight.restconf.common.context.NormalizedNodeContext; import org.opendaylight.restconf.nb.rfc8040.MediaTypes; +import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload; /** * Container that provides access to the data-model specific operations supported by the server. @@ -46,7 +46,7 @@ public interface RestconfOperationsService { * * @param identifier path parameter * @param uriInfo URI information - * @return {@link NormalizedNodeContext} + * @return {@link NormalizedNodePayload} */ @GET @Path("/operations/{identifier:.+}") @@ -57,5 +57,5 @@ public interface RestconfOperationsService { MediaType.APPLICATION_XML, MediaType.TEXT_XML }) - NormalizedNodeContext getOperations(@PathParam("identifier") String identifier, @Context UriInfo uriInfo); + NormalizedNodePayload getOperations(@PathParam("identifier") String identifier, @Context UriInfo uriInfo); } diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/api/RestconfService.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/api/RestconfService.java index 4e1d7f4838..4f31b392ba 100644 --- a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/api/RestconfService.java +++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/api/RestconfService.java @@ -11,8 +11,8 @@ import javax.ws.rs.GET; import javax.ws.rs.Path; import javax.ws.rs.Produces; import javax.ws.rs.core.MediaType; -import org.opendaylight.restconf.common.context.NormalizedNodeContext; import org.opendaylight.restconf.nb.rfc8040.MediaTypes; +import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload; /** * Service for getting yang library version. @@ -21,7 +21,7 @@ public interface RestconfService { /** * Get yang library version. * - * @return {@link NormalizedNodeContext} + * @return {@link NormalizedNodePayload} */ @GET @Path("/yang-library-version") @@ -32,5 +32,5 @@ public interface RestconfService { MediaType.APPLICATION_XML, MediaType.TEXT_XML }) - NormalizedNodeContext getLibraryVersion(); + NormalizedNodePayload getLibraryVersion(); } diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/api/RestconfStreamsSubscriptionService.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/api/RestconfStreamsSubscriptionService.java index 7a5e0675fe..9607dec74b 100644 --- a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/api/RestconfStreamsSubscriptionService.java +++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/api/RestconfStreamsSubscriptionService.java @@ -13,7 +13,7 @@ import javax.ws.rs.Path; import javax.ws.rs.PathParam; import javax.ws.rs.core.Context; import javax.ws.rs.core.UriInfo; -import org.opendaylight.restconf.common.context.NormalizedNodeContext; +import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload; /** * Subscribing to streams. @@ -26,10 +26,10 @@ public interface RestconfStreamsSubscriptionService { * name of stream * @param uriInfo * URI info - * @return {@link NormalizedNodeContext} + * @return {@link NormalizedNodePayload} */ @GET @Path("data/ietf-restconf-monitoring:restconf-state/streams/stream/{identifier:.+}") - NormalizedNodeContext subscribeToStream(@Encoded @PathParam("identifier") String identifier, + NormalizedNodePayload subscribeToStream(@Encoded @PathParam("identifier") String identifier, @Context UriInfo uriInfo); } diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfDataServiceImpl.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfDataServiceImpl.java index 2681ececd2..4c78357906 100644 --- a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfDataServiceImpl.java +++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfDataServiceImpl.java @@ -51,12 +51,13 @@ import org.opendaylight.mdsal.dom.api.DOMSchemaService; import org.opendaylight.mdsal.dom.spi.SimpleDOMActionResult; import org.opendaylight.restconf.common.context.InstanceIdentifierContext; import org.opendaylight.restconf.common.context.NormalizedNodeContext; -import org.opendaylight.restconf.common.context.WriterParameters; import org.opendaylight.restconf.common.errors.RestconfDocumentedException; import org.opendaylight.restconf.common.patch.PatchContext; import org.opendaylight.restconf.common.patch.PatchStatusContext; import org.opendaylight.restconf.nb.rfc8040.Rfc8040; import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler; +import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload; +import org.opendaylight.restconf.nb.rfc8040.legacy.QueryParameters; import org.opendaylight.restconf.nb.rfc8040.rests.services.api.RestconfDataService; import org.opendaylight.restconf.nb.rfc8040.rests.services.api.RestconfStreamsSubscriptionService; import org.opendaylight.restconf.nb.rfc8040.rests.transactions.MdsalRestconfStrategy; @@ -147,7 +148,7 @@ public class RestconfDataServiceImpl implements RestconfDataService { final EffectiveModelContext schemaContextRef = schemaContextHandler.get(); final InstanceIdentifierContext instanceIdentifier = ParserIdentifier.toInstanceIdentifier( identifier, schemaContextRef, Optional.of(mountPointService)); - final WriterParameters parameters = ReadDataTransactionUtil.parseUriParameters(instanceIdentifier, uriInfo); + final QueryParameters parameters = ReadDataTransactionUtil.parseUriParameters(instanceIdentifier, uriInfo); final DOMMountPoint mountPoint = instanceIdentifier.getMountPoint(); @@ -226,7 +227,7 @@ public class RestconfDataServiceImpl implements RestconfDataService { } @Override - public Response putData(final String identifier, final NormalizedNodeContext payload, final UriInfo uriInfo) { + public Response putData(final String identifier, final NormalizedNodePayload payload, final UriInfo uriInfo) { requireNonNull(payload); final QueryParams checkedParms = checkQueryParameters(uriInfo); @@ -302,12 +303,12 @@ public class RestconfDataServiceImpl implements RestconfDataService { } @Override - public Response postData(final String identifier, final NormalizedNodeContext payload, final UriInfo uriInfo) { + public Response postData(final String identifier, final NormalizedNodePayload payload, final UriInfo uriInfo) { return postData(payload, uriInfo); } @Override - public Response postData(final NormalizedNodeContext payload, final UriInfo uriInfo) { + public Response postData(final NormalizedNodePayload payload, final UriInfo uriInfo) { requireNonNull(payload); if (payload.getInstanceIdentifierContext().getSchemaNode() instanceof ActionDefinition) { return invokeAction(payload); @@ -345,7 +346,7 @@ public class RestconfDataServiceImpl implements RestconfDataService { } @Override - public Response patchData(final String identifier, final NormalizedNodeContext payload, final UriInfo uriInfo) { + public Response patchData(final String identifier, final NormalizedNodePayload payload, final UriInfo uriInfo) { requireNonNull(payload); final InstanceIdentifierContext iid = payload.getInstanceIdentifierContext(); diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfImpl.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfImpl.java index bc0ecb449e..bbd2a731ba 100644 --- a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfImpl.java +++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfImpl.java @@ -11,9 +11,9 @@ import static java.util.Objects.requireNonNull; import javax.ws.rs.Path; import org.opendaylight.restconf.common.context.InstanceIdentifierContext; -import org.opendaylight.restconf.common.context.NormalizedNodeContext; import org.opendaylight.restconf.nb.rfc8040.Rfc8040.IetfYangLibrary; import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler; +import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload; import org.opendaylight.restconf.nb.rfc8040.rests.services.api.RestconfService; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.restconf.rev170126.Restconf; import org.opendaylight.yangtools.yang.common.QName; @@ -35,7 +35,7 @@ public class RestconfImpl implements RestconfService { } @Override - public NormalizedNodeContext getLibraryVersion() { + public NormalizedNodePayload getLibraryVersion() { final EffectiveModelContext context = schemaContextHandler.get(); // FIXME: why are we going through a grouping here?! @@ -51,7 +51,7 @@ public class RestconfImpl implements RestconfService { (LeafSchemaNode) ((ContainerSchemaNode) grouping.getDataChildByName(Restconf.QNAME)) .getDataChildByName(YANG_LIBRARY_VERSION); - return new NormalizedNodeContext(new InstanceIdentifierContext<>( + return NormalizedNodePayload.of(new InstanceIdentifierContext<>( YangInstanceIdentifier.of(YANG_LIBRARY_VERSION), schemaNode, null, context), ImmutableNodes.leafNode(YANG_LIBRARY_VERSION, IetfYangLibrary.REVISION.toString())); } diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfInvokeOperationsServiceImpl.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfInvokeOperationsServiceImpl.java index 4c24e478dd..f2c70e8e26 100644 --- a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfInvokeOperationsServiceImpl.java +++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfInvokeOperationsServiceImpl.java @@ -34,6 +34,7 @@ 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.handlers.SchemaContextHandler; +import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload; import org.opendaylight.restconf.nb.rfc8040.rests.services.api.RestconfInvokeOperationsService; import org.opendaylight.yangtools.yang.common.ErrorTag; import org.opendaylight.yangtools.yang.common.ErrorType; @@ -73,7 +74,7 @@ public class RestconfInvokeOperationsServiceImpl implements RestconfInvokeOperat } @Override - public void invokeRpc(final String identifier, final NormalizedNodeContext payload, final UriInfo uriInfo, + public void invokeRpc(final String identifier, final NormalizedNodePayload payload, final UriInfo uriInfo, final AsyncResponse ar) { final SchemaNode schema = payload.getInstanceIdentifierContext().getSchemaNode(); final QName rpcName = schema.getQName(); diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfOperationsServiceImpl.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfOperationsServiceImpl.java index 28c0cd14cd..cf9725ea2b 100644 --- a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfOperationsServiceImpl.java +++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfOperationsServiceImpl.java @@ -17,10 +17,10 @@ import org.opendaylight.mdsal.dom.api.DOMMountPointService; import org.opendaylight.mdsal.dom.api.DOMSchemaService; import org.opendaylight.restconf.common.OperationsContent; 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.util.OperationsResourceUtils; import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler; +import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload; import org.opendaylight.restconf.nb.rfc8040.rests.services.api.RestconfOperationsService; import org.opendaylight.restconf.nb.rfc8040.utils.RestconfConstants; import org.opendaylight.restconf.nb.rfc8040.utils.parser.ParserIdentifier; @@ -64,7 +64,7 @@ public class RestconfOperationsServiceImpl implements RestconfOperationsService } @Override - public NormalizedNodeContext getOperations(final String identifier, final UriInfo uriInfo) { + public NormalizedNodePayload getOperations(final String identifier, final UriInfo uriInfo) { if (!identifier.contains(RestconfConstants.MOUNT)) { final String errMsg = "URI has bad format. If operations behind mount point should be showed, URI has to " + " end with " + RestconfConstants.MOUNT; @@ -76,7 +76,8 @@ public class RestconfOperationsServiceImpl implements RestconfOperationsService final InstanceIdentifierContext mountPointIdentifier = ParserIdentifier.toInstanceIdentifier(identifier, schemaContextHandler.get(), Optional.of(mountPointService)); final DOMMountPoint mountPoint = mountPointIdentifier.getMountPoint(); - return OperationsResourceUtils.contextForModelContext(modelContext(mountPoint), mountPoint); + final var entry = OperationsResourceUtils.contextForModelContext(modelContext(mountPoint), mountPoint); + return NormalizedNodePayload.of(entry.getKey(), entry.getValue()); } private static EffectiveModelContext modelContext(final DOMMountPoint mountPoint) { diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfStreamsSubscriptionServiceImpl.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfStreamsSubscriptionServiceImpl.java index 7306c70ddb..9e31cfba3c 100644 --- a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfStreamsSubscriptionServiceImpl.java +++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfStreamsSubscriptionServiceImpl.java @@ -9,7 +9,6 @@ package org.opendaylight.restconf.nb.rfc8040.rests.services.impl; import static com.google.common.base.Preconditions.checkState; -import com.google.common.collect.ImmutableMap; import java.net.URI; import java.time.Instant; import java.time.format.DateTimeFormatter; @@ -26,9 +25,9 @@ import org.eclipse.jdt.annotation.NonNull; import org.opendaylight.mdsal.dom.api.DOMDataBroker; import org.opendaylight.mdsal.dom.api.DOMNotificationService; 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.handlers.SchemaContextHandler; +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.utils.RestconfStreamsConstants; import org.opendaylight.restconf.nb.rfc8040.streams.Configuration; @@ -36,7 +35,6 @@ import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types. 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.impl.schema.ImmutableNodes; import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode; import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; import org.opendaylight.yangtools.yang.model.api.Module; @@ -80,7 +78,7 @@ public class RestconfStreamsSubscriptionServiceImpl implements RestconfStreamsSu } @Override - public NormalizedNodeContext subscribeToStream(final String identifier, final UriInfo uriInfo) { + public NormalizedNodePayload subscribeToStream(final String identifier, final UriInfo uriInfo) { final NotificationQueryParams notificationQueryParams = NotificationQueryParams.fromUriInfo(uriInfo); final URI response; @@ -95,8 +93,8 @@ public class RestconfStreamsSubscriptionServiceImpl implements RestconfStreamsSu } // prepare node with value of location - return new NormalizedNodeContext(prepareIIDSubsStreamOutput(handlersHolder.getSchemaHandler()), - ImmutableNodes.leafNode(LOCATION_NODEID, response.toString()), ImmutableMap.of("Location", response)); + return NormalizedNodePayload.ofLocation(prepareIIDSubsStreamOutput(handlersHolder.getSchemaHandler()), + LOCATION_NODEID, response); } /** diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/PlainPatchDataTransactionUtil.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/PlainPatchDataTransactionUtil.java index d61018323d..20cf1bd677 100644 --- a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/PlainPatchDataTransactionUtil.java +++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/PlainPatchDataTransactionUtil.java @@ -13,8 +13,8 @@ import javax.ws.rs.core.Response; import javax.ws.rs.core.Response.Status; import org.opendaylight.mdsal.common.api.CommitInfo; import org.opendaylight.mdsal.dom.api.DOMTransactionChain; -import org.opendaylight.restconf.common.context.NormalizedNodeContext; import org.opendaylight.restconf.common.errors.RestconfDocumentedException; +import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload; import org.opendaylight.restconf.nb.rfc8040.rests.transactions.RestconfStrategy; import org.opendaylight.restconf.nb.rfc8040.rests.transactions.RestconfTransaction; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; @@ -42,7 +42,7 @@ public final class PlainPatchDataTransactionUtil { * @param strategy object that perform the actual DS operations * @return {@link Response} */ - public static Response patchData(final NormalizedNodeContext payload, + public static Response patchData(final NormalizedNodePayload payload, final RestconfStrategy strategy, final EffectiveModelContext schemaContext) { diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/PostDataTransactionUtil.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/PostDataTransactionUtil.java index 8d3aaf0757..a45c3525bd 100644 --- a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/PostDataTransactionUtil.java +++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/PostDataTransactionUtil.java @@ -18,8 +18,8 @@ import org.opendaylight.mdsal.common.api.CommitInfo; import org.opendaylight.mdsal.common.api.LogicalDatastoreType; import org.opendaylight.mdsal.dom.api.DOMTransactionChain; 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.legacy.NormalizedNodePayload; import org.opendaylight.restconf.nb.rfc8040.rests.transactions.RestconfStrategy; import org.opendaylight.restconf.nb.rfc8040.rests.transactions.RestconfTransaction; import org.opendaylight.restconf.nb.rfc8040.rests.utils.RestconfDataServiceConstant.PostPutQueryParameters.Insert; @@ -61,7 +61,7 @@ public final class PostDataTransactionUtil { * @param insert insert * @return {@link Response} */ - public static Response postData(final UriInfo uriInfo, final NormalizedNodeContext payload, + public static Response postData(final UriInfo uriInfo, final NormalizedNodePayload payload, final RestconfStrategy strategy, final EffectiveModelContext schemaContext, final Insert insert, final String point) { diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/PutDataTransactionUtil.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/PutDataTransactionUtil.java index 9fb90bf912..f5c53eced9 100644 --- a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/PutDataTransactionUtil.java +++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/PutDataTransactionUtil.java @@ -15,8 +15,8 @@ import org.opendaylight.mdsal.common.api.CommitInfo; import org.opendaylight.mdsal.common.api.LogicalDatastoreType; import org.opendaylight.mdsal.dom.api.DOMTransactionChain; 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.legacy.NormalizedNodePayload; import org.opendaylight.restconf.nb.rfc8040.rests.transactions.RestconfStrategy; import org.opendaylight.restconf.nb.rfc8040.rests.transactions.RestconfTransaction; import org.opendaylight.restconf.nb.rfc8040.rests.utils.RestconfDataServiceConstant.PostPutQueryParameters.Insert; @@ -56,7 +56,7 @@ public final class PutDataTransactionUtil { * @param insert query parameter * @return {@link Response} */ - public static Response putData(final NormalizedNodeContext payload, final EffectiveModelContext schemaContext, + public static Response putData(final NormalizedNodePayload payload, final EffectiveModelContext schemaContext, final RestconfStrategy strategy, final Insert insert, final String point) { final YangInstanceIdentifier path = payload.getInstanceIdentifierContext().getInstanceIdentifier(); diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/ReadDataTransactionUtil.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/ReadDataTransactionUtil.java index 30012ecd48..e7045bd32a 100644 --- a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/ReadDataTransactionUtil.java +++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/ReadDataTransactionUtil.java @@ -27,10 +27,9 @@ import org.eclipse.jdt.annotation.Nullable; import org.opendaylight.mdsal.common.api.LogicalDatastoreType; import org.opendaylight.mdsal.dom.api.DOMTransactionChain; import org.opendaylight.restconf.common.context.InstanceIdentifierContext; -import org.opendaylight.restconf.common.context.WriterParameters; -import org.opendaylight.restconf.common.context.WriterParameters.WriterParametersBuilder; import org.opendaylight.restconf.common.errors.RestconfDocumentedException; import org.opendaylight.restconf.common.errors.RestconfError; +import org.opendaylight.restconf.nb.rfc8040.legacy.QueryParameters; import org.opendaylight.restconf.nb.rfc8040.rests.transactions.RestconfStrategy; import org.opendaylight.restconf.nb.rfc8040.rests.utils.RestconfDataServiceConstant.ReadData.WithDefaults; import org.opendaylight.yangtools.yang.common.ErrorTag; @@ -101,11 +100,11 @@ public final class ReadDataTransactionUtil { * * @param identifier {@link InstanceIdentifierContext} * @param uriInfo URI info - * @return {@link WriterParameters} + * @return {@link QueryParameters} */ - public static WriterParameters parseUriParameters(final InstanceIdentifierContext identifier, + public static QueryParameters parseUriParameters(final InstanceIdentifierContext identifier, final UriInfo uriInfo) { - final WriterParametersBuilder builder = new WriterParametersBuilder(); + final QueryParameters.Builder builder = QueryParameters.builder(); if (uriInfo == null) { return builder.build(); } 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 74bb1b71d7..5df7873806 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 @@ -60,6 +60,7 @@ 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.SchemaContextHandler; +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; @@ -76,6 +77,7 @@ 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; @@ -133,108 +135,108 @@ public class RestconfDataServiceImplTest { @Before public void setUp() throws Exception { doReturn(Set.of()).when(queryParamenters).entrySet(); - doReturn(queryParamenters).when(this.uriInfo).getQueryParameters(); + 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).findChild(this.iidBase).orElseThrow( + 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(); DOMDataBroker mockDataBroker = mock(DOMDataBroker.class); - doReturn(this.read).when(mockDataBroker).newReadOnlyTransaction(); - doReturn(this.readWrite).when(mockDataBroker).newReadWriteTransaction(); - doReturn(this.write).when(mockDataBroker).newWriteOnlyTransaction(); + doReturn(read).when(mockDataBroker).newReadOnlyTransaction(); + doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction(); + doReturn(write).when(mockDataBroker).newWriteOnlyTransaction(); final SchemaContextHandler schemaContextHandler = new SchemaContextHandler( mockDataBroker, mock(DOMSchemaService.class)); - schemaContextHandler.onModelContextUpdated(this.contextRef); - this.dataService = new RestconfDataServiceImpl(schemaContextHandler, mockDataBroker, mountPointService, - this.delegRestconfSubscrService, this.actionService, 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)); - doReturn(Optional.of(FixedDOMSchemaService.of(this.contextRef))).when(this.mountPoint) + doReturn(Optional.of(FixedDOMSchemaService.of(contextRef))).when(mountPoint) .getService(DOMSchemaService.class); - doReturn(Optional.of(this.mountDataBroker)).when(this.mountPoint).getService(DOMDataBroker.class); - doReturn(Optional.empty()).when(this.mountPoint).getService(NetconfDataTreeService.class); - doReturn(this.read).when(this.mountDataBroker).newReadOnlyTransaction(); - doReturn(this.readWrite).when(this.mountDataBroker).newReadWriteTransaction(); + 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, ((NormalizedNodeContext) 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()); @@ -259,14 +261,14 @@ 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()); @@ -275,19 +277,19 @@ public class RestconfDataServiceImplTest { final NormalizedNode data = ((NormalizedNodeContext) response.getEntity()).getData(); assertTrue(data instanceof ContainerNode); assertEquals(3, ((ContainerNode) data).size()); - assertTrue(((ContainerNode) data).findChildByArg(this.buildPlayerCont.getIdentifier()).isPresent()); - assertTrue(((ContainerNode) data).findChildByArg(this.buildLibraryCont.getIdentifier()).isPresent()); - assertTrue(((ContainerNode) data).findChildByArg(this.buildPlaylistList.getIdentifier()).isPresent()); + 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); } /** @@ -298,11 +300,11 @@ public class RestconfDataServiceImplTest { final MultivaluedHashMap parameters = new MultivaluedHashMap<>(); 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(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()); @@ -311,11 +313,11 @@ public class RestconfDataServiceImplTest { final NormalizedNode data = ((NormalizedNodeContext) response.getEntity()).getData(); // config data present - assertTrue(((ContainerNode) data).findChildByArg(this.buildPlayerCont.getIdentifier()).isPresent()); - assertTrue(((ContainerNode) data).findChildByArg(this.buildLibraryCont.getIdentifier()).isPresent()); + assertTrue(((ContainerNode) data).findChildByArg(buildPlayerCont.getIdentifier()).isPresent()); + assertTrue(((ContainerNode) data).findChildByArg(buildLibraryCont.getIdentifier()).isPresent()); // state data absent - assertFalse(((ContainerNode) data).findChildByArg(this.buildPlaylistList.getIdentifier()).isPresent()); + assertFalse(((ContainerNode) data).findChildByArg(buildPlaylistList.getIdentifier()).isPresent()); } /** @@ -326,11 +328,11 @@ public class RestconfDataServiceImplTest { final MultivaluedHashMap parameters = new MultivaluedHashMap<>(); parameters.put("content", List.of("nonconfig")); - doReturn(parameters).when(this.uriInfo).getQueryParameters(); - 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()); @@ -339,23 +341,23 @@ public class RestconfDataServiceImplTest { final NormalizedNode data = ((NormalizedNodeContext) response.getEntity()).getData(); // state data present - assertTrue(((ContainerNode) data).findChildByArg(this.buildPlayerCont.getIdentifier()).isPresent()); - assertTrue(((ContainerNode) data).findChildByArg(this.buildPlaylistList.getIdentifier()).isPresent()); + assertTrue(((ContainerNode) data).findChildByArg(buildPlayerCont.getIdentifier()).isPresent()); + assertTrue(((ContainerNode) data).findChildByArg(buildPlaylistList.getIdentifier()).isPresent()); // config data absent - assertFalse(((ContainerNode) data).findChildByArg(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); + new InstanceIdentifierContext<>(iidBase, schemaNode, null, contextRef); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseCont); - doReturn(immediateTrueFluentFuture()).when(this.read) - .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); + 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()); } @@ -363,65 +365,55 @@ public class RestconfDataServiceImplTest { @Test public void testPutDataWithMountPoint() { final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iidBase, this.schemaNode, mountPoint, this.contextRef); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseCont); + new InstanceIdentifierContext<>(iidBase, schemaNode, mountPoint, contextRef); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseCont); - doReturn(immediateTrueFluentFuture()).when(this.read) - .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); + 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(); + doReturn(new MultivaluedHashMap()).when(uriInfo).getQueryParameters(); final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iidBase, null, null, this.contextRef); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, buildList); + 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 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, entryNode); - 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()); } @@ -431,11 +423,11 @@ 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()); } @@ -443,23 +435,23 @@ public class RestconfDataServiceImplTest { @Test public void testPatchData() { final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iidBase, this.schemaNode, null, this.contextRef); + 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"); - 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()); @@ -468,23 +460,23 @@ public class RestconfDataServiceImplTest { @Test public void testPatchDataMountPoint() throws Exception { final InstanceIdentifierContext iidContext = new InstanceIdentifierContext<>( - this.iidBase, this.schemaNode, this.mountPoint, this.contextRef); + 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"); - 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()); @@ -493,24 +485,24 @@ public class RestconfDataServiceImplTest { @Test public void testPatchDataDeleteNotExist() { final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iidBase, this.schemaNode, null, this.contextRef); + 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"); - 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()); @@ -524,11 +516,11 @@ public class RestconfDataServiceImplTest { @Test public void testGetRestconfStrategy() { - RestconfStrategy restconfStrategy = this.dataService.getRestconfStrategy(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(this.mountPoint); + doReturn(Optional.of(netconfService)).when(mountPoint).getService(NetconfDataTreeService.class); + restconfStrategy = dataService.getRestconfStrategy(mountPoint); assertTrue(restconfStrategy instanceof NetconfRestconfStrategy); } } diff --git a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfInvokeOperationsServiceImplTest.java b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfInvokeOperationsServiceImplTest.java index 0c6583f002..5d39f5039a 100644 --- a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfInvokeOperationsServiceImplTest.java +++ b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfInvokeOperationsServiceImplTest.java @@ -50,6 +50,7 @@ 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.SchemaContextHandler; +import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.common.RpcError; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier; @@ -92,8 +93,8 @@ public class RestconfInvokeOperationsServiceImplTest { final SchemaContextHandler schemaContextHandler = new SchemaContextHandler(dataBroker, mock(DOMSchemaService.class)); schemaContextHandler.onModelContextUpdated(contextRef); - this.invokeOperationsService = - new RestconfInvokeOperationsServiceImpl(this.rpcService, schemaContextHandler); + invokeOperationsService = + new RestconfInvokeOperationsServiceImpl(rpcService, schemaContextHandler); } @Test @@ -175,7 +176,7 @@ public class RestconfInvokeOperationsServiceImplTest { assertEquals(OUTPUT, rpcResult.getResult()); } - private NormalizedNodeContext prepNNC(final NormalizedNode result) { + private NormalizedNodePayload prepNNC(final NormalizedNode result) { final InstanceIdentifierContext context = mock(InstanceIdentifierContext.class); final RpcDefinition schemaNode = mock(RpcDefinition.class); final QName qname = QName.create("invoke:rpc:module", "2013-12-03", "rpcTest"); @@ -185,6 +186,6 @@ public class RestconfInvokeOperationsServiceImplTest { final DOMRpcResult domRpcResult = mock(DOMRpcResult.class); doReturn(immediateFluentFuture(domRpcResult)).when(rpcService).invokeRpc(qname, data); doReturn(result).when(domRpcResult).getResult(); - return new NormalizedNodeContext(context, data); + return NormalizedNodePayload.of(context, data); } } diff --git a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/PlainPatchDataTransactionUtilTest.java b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/PlainPatchDataTransactionUtilTest.java index 270d8e07b7..3caf92fe32 100644 --- a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/PlainPatchDataTransactionUtilTest.java +++ b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/PlainPatchDataTransactionUtilTest.java @@ -28,8 +28,8 @@ import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction; 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.nb.rfc8040.TestRestconfUtils; +import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload; 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; @@ -71,7 +71,7 @@ public class PlainPatchDataTransactionUtilTest { @Before public void setUp() throws Exception { - this.schema = YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles(PATH_FOR_NEW_SCHEMA_CONTEXT)); + schema = YangParserTestUtils.parseYangFiles(TestRestconfUtils.loadFiles(PATH_FOR_NEW_SCHEMA_CONTEXT)); final QName qnJukebox = QName.create("http://example.com/ns/example-jukebox", "2015-04-04", "jukebox"); final QName qnPlayer = QName.create(qnJukebox, "player"); @@ -84,29 +84,29 @@ public class PlainPatchDataTransactionUtilTest { final NodeIdentifierWithPredicates nidBandB = NodeIdentifierWithPredicates.of(qnPlaylist, qnPlaylistKey, "MyFavoriteBand-B"); - this.iidGap = YangInstanceIdentifier.builder() + iidGap = YangInstanceIdentifier.builder() .node(qnJukebox) .node(qnPlayer) .node(qnGap) .build(); - this.schemaNodeForGap = DataSchemaContextTree.from(this.schema).findChild(this.iidGap).orElseThrow() + schemaNodeForGap = DataSchemaContextTree.from(schema).findChild(iidGap).orElseThrow() .getDataSchemaNode(); - this.iidJukebox = YangInstanceIdentifier.builder() + iidJukebox = YangInstanceIdentifier.builder() .node(qnJukebox) .build(); - this.schemaNodeForJukebox = DataSchemaContextTree.from(this.schema) - .findChild(this.iidJukebox).orElseThrow().getDataSchemaNode(); + schemaNodeForJukebox = DataSchemaContextTree.from(schema) + .findChild(iidJukebox).orElseThrow().getDataSchemaNode(); - this.leafGap = Builders.leafBuilder() + leafGap = Builders.leafBuilder() .withNodeIdentifier(new NodeIdentifier(qnGap)) .withValue(0.2) .build(); final ContainerNode playerContainer = Builders.containerBuilder() .withNodeIdentifier(new NodeIdentifier(qnPlayer)) - .withChild(this.leafGap) + .withChild(leafGap) .build(); - this.jukeboxContainerWithPlayer = Builders.containerBuilder() + jukeboxContainerWithPlayer = Builders.containerBuilder() .withNodeIdentifier(new NodeIdentifier(qnJukebox)) .withChild(playerContainer) .build(); @@ -146,78 +146,78 @@ public class PlainPatchDataTransactionUtilTest { .withChild(entryBandA) .withChild(entryBandB) .build(); - this.jukeboxContainerWithPlaylist = Builders.containerBuilder() + jukeboxContainerWithPlaylist = Builders.containerBuilder() .withNodeIdentifier(new NodeIdentifier(qnJukebox)) .withChild(listBands) .build(); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).lock(); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).unlock(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).lock(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).unlock(); } @Test public void testPatchContainerData() { final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iidJukebox, this.schemaNodeForJukebox, null, this.schema); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.jukeboxContainerWithPlayer); + new InstanceIdentifierContext<>(iidJukebox, schemaNodeForJukebox, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, jukeboxContainerWithPlayer); - doReturn(this.readWrite).when(this.mockDataBroker).newReadWriteTransaction(); - doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit(); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).commit(); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).merge(any(), any(),any(), + doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction(); + doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).merge(any(), any(),any(), any()); - PlainPatchDataTransactionUtil.patchData(payload, new MdsalRestconfStrategy(mockDataBroker), this.schema); - verify(this.readWrite).merge(LogicalDatastoreType.CONFIGURATION, + PlainPatchDataTransactionUtil.patchData(payload, new MdsalRestconfStrategy(mockDataBroker), schema); + verify(readWrite).merge(LogicalDatastoreType.CONFIGURATION, payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData()); PlainPatchDataTransactionUtil.patchData(payload, new NetconfRestconfStrategy(netconfService), - this.schema); - verify(this.netconfService).merge(LogicalDatastoreType.CONFIGURATION, + schema); + verify(netconfService).merge(LogicalDatastoreType.CONFIGURATION, payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData(), Optional.empty()); } @Test public void testPatchLeafData() { final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iidGap, this.schemaNodeForGap, null, this.schema); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.leafGap); + new InstanceIdentifierContext<>(iidGap, schemaNodeForGap, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, leafGap); - doReturn(this.readWrite).when(this.mockDataBroker).newReadWriteTransaction(); - doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit(); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService) + doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction(); + doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService) .merge(any(), any(), any(), any()); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).commit(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit(); - PlainPatchDataTransactionUtil.patchData(payload, new MdsalRestconfStrategy(mockDataBroker), this.schema); - verify(this.readWrite).merge(LogicalDatastoreType.CONFIGURATION, + PlainPatchDataTransactionUtil.patchData(payload, new MdsalRestconfStrategy(mockDataBroker), schema); + verify(readWrite).merge(LogicalDatastoreType.CONFIGURATION, payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData()); PlainPatchDataTransactionUtil.patchData(payload, new NetconfRestconfStrategy(netconfService), - this.schema); - verify(this.netconfService).lock(); - verify(this.netconfService).merge(LogicalDatastoreType.CONFIGURATION, + schema); + verify(netconfService).lock(); + verify(netconfService).merge(LogicalDatastoreType.CONFIGURATION, payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData(), Optional.empty()); } @Test public void testPatchListData() { final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iidJukebox, this.schemaNodeForJukebox, null, this.schema); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.jukeboxContainerWithPlaylist); + new InstanceIdentifierContext<>(iidJukebox, schemaNodeForJukebox, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, jukeboxContainerWithPlaylist); - doReturn(this.readWrite).when(this.mockDataBroker).newReadWriteTransaction(); - doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit(); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).commit(); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService) + doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction(); + doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService) .merge(any(), any(),any(),any()); - PlainPatchDataTransactionUtil.patchData(payload, new MdsalRestconfStrategy(mockDataBroker), this.schema); - verify(this.readWrite).merge(LogicalDatastoreType.CONFIGURATION, this.iidJukebox, payload.getData()); + PlainPatchDataTransactionUtil.patchData(payload, new MdsalRestconfStrategy(mockDataBroker), schema); + verify(readWrite).merge(LogicalDatastoreType.CONFIGURATION, iidJukebox, payload.getData()); PlainPatchDataTransactionUtil.patchData(payload, new NetconfRestconfStrategy(netconfService), - this.schema); - verify(this.netconfService).merge(LogicalDatastoreType.CONFIGURATION, this.iidJukebox, payload.getData(), + schema); + verify(netconfService).merge(LogicalDatastoreType.CONFIGURATION, iidJukebox, payload.getData(), Optional.empty()); } } diff --git a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/PostDataTransactionUtilTest.java b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/PostDataTransactionUtilTest.java index 75e3f6da9c..ba5039ef8c 100644 --- a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/PostDataTransactionUtilTest.java +++ b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/PostDataTransactionUtilTest.java @@ -39,9 +39,9 @@ import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction; 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.legacy.NormalizedNodePayload; 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; @@ -79,7 +79,7 @@ public class PostDataTransactionUtilTest { @Before public void setUp() throws Exception { - this.schema = + 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"); @@ -89,10 +89,10 @@ public class PostDataTransactionUtilTest { final QName listKeyQname = QName.create(baseQName, "name"); final NodeIdentifierWithPredicates nodeWithKey = NodeIdentifierWithPredicates.of(listQname, listKeyQname, "name of band"); - this.iid2 = YangInstanceIdentifier.builder() + iid2 = YangInstanceIdentifier.builder() .node(baseQName) .build(); - this.iidList = YangInstanceIdentifier.builder() + iidList = YangInstanceIdentifier.builder() .node(baseQName) .node(listQname) .build(); @@ -105,7 +105,7 @@ public class PostDataTransactionUtilTest { .withNodeIdentifier(new NodeIdentifier(containerQname)) .withChild(buildLeaf) .build(); - this.buildBaseCont = Builders.containerBuilder() + buildBaseCont = Builders.containerBuilder() .withNodeIdentifier(new NodeIdentifier(baseQName)) .withChild(buildPlayerCont) .build(); @@ -123,131 +123,131 @@ public class PostDataTransactionUtilTest { .withChild(content) .withChild(content2) .build(); - this.buildList = Builders.mapBuilder() + buildList = Builders.mapBuilder() .withNodeIdentifier(new NodeIdentifier(listQname)) .withChild(mapEntryNode) .build(); - doReturn(UriBuilder.fromUri("http://localhost:8181/restconf/16/")).when(this.uriInfo).getBaseUriBuilder(); - doReturn(this.readWrite).when(this.mockDataBroker).newReadWriteTransaction(); + doReturn(UriBuilder.fromUri("http://localhost:8181/restconf/16/")).when(uriInfo).getBaseUriBuilder(); + doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction(); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).lock(); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).unlock(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).lock(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).unlock(); } @Test public void testPostContainerData() { final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iid2, null, null, this.schema); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseCont); + new InstanceIdentifierContext<>(iid2, null, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseCont); - doReturn(immediateFalseFluentFuture()).when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, - this.iid2); + doReturn(immediateFalseFluentFuture()).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, + iid2); final NodeIdentifier identifier = ((ContainerNode) ((Collection) payload.getData().body()).iterator().next()).getIdentifier(); final YangInstanceIdentifier node = payload.getInstanceIdentifierContext().getInstanceIdentifier().node(identifier); - doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, node.getParent(), payload.getData()); - doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit(); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).commit(); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService) + doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, node.getParent(), payload.getData()); + doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService) .create(LogicalDatastoreType.CONFIGURATION, payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData(), Optional.empty()); - Response response = PostDataTransactionUtil.postData(this.uriInfo, payload, - new MdsalRestconfStrategy(mockDataBroker), this.schema, null, null); + Response response = PostDataTransactionUtil.postData(uriInfo, payload, + new MdsalRestconfStrategy(mockDataBroker), schema, null, null); assertEquals(201, response.getStatus()); - verify(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iid2); - verify(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, + verify(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iid2); + verify(readWrite).put(LogicalDatastoreType.CONFIGURATION, payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData()); - response = PostDataTransactionUtil.postData(this.uriInfo, payload, - new NetconfRestconfStrategy(netconfService), this.schema, null, null); + response = PostDataTransactionUtil.postData(uriInfo, payload, + new NetconfRestconfStrategy(netconfService), schema, null, null); assertEquals(201, response.getStatus()); - verify(this.netconfService).create(LogicalDatastoreType.CONFIGURATION, + verify(netconfService).create(LogicalDatastoreType.CONFIGURATION, payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData(), Optional.empty()); } @Test public void testPostListData() { final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iidList, null, null, this.schema); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildList); + new InstanceIdentifierContext<>(iidList, null, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildList); final MapNode data = (MapNode) payload.getData(); 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, entryNode); - doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit(); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService) + doReturn(immediateFalseFluentFuture()).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, node); + doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, node, entryNode); + doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService) .merge(any(), any(), any(), any()); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).commit(); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).create( + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).create( LogicalDatastoreType.CONFIGURATION, node, entryNode, Optional.empty()); - Response response = PostDataTransactionUtil.postData(this.uriInfo, payload, - new MdsalRestconfStrategy(mockDataBroker), this.schema, null, null); + Response response = PostDataTransactionUtil.postData(uriInfo, payload, + new MdsalRestconfStrategy(mockDataBroker), schema, null, null); assertEquals(201, response.getStatus()); assertThat(URLDecoder.decode(response.getLocation().toString(), StandardCharsets.UTF_8), containsString(identifier.getValue(identifier.keySet().iterator().next()).toString())); - verify(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, node); - verify(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, node, entryNode); + verify(readWrite).exists(LogicalDatastoreType.CONFIGURATION, node); + verify(readWrite).put(LogicalDatastoreType.CONFIGURATION, node, entryNode); - response = PostDataTransactionUtil.postData(this.uriInfo, payload, - new NetconfRestconfStrategy(netconfService), this.schema, null, null); + response = PostDataTransactionUtil.postData(uriInfo, payload, + new NetconfRestconfStrategy(netconfService), schema, null, null); assertEquals(201, response.getStatus()); assertThat(URLDecoder.decode(response.getLocation().toString(), StandardCharsets.UTF_8), containsString(identifier.getValue(identifier.keySet().iterator().next()).toString())); - verify(this.netconfService).create(LogicalDatastoreType.CONFIGURATION, node, entryNode, + verify(netconfService).create(LogicalDatastoreType.CONFIGURATION, node, entryNode, Optional.empty()); } @Test public void testPostDataFail() { final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iid2, null, null, this.schema); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseCont); + new InstanceIdentifierContext<>(iid2, null, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseCont); - doReturn(immediateFalseFluentFuture()).when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, - this.iid2); + doReturn(immediateFalseFluentFuture()).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, + iid2); final NodeIdentifier identifier = ((ContainerNode) ((Collection) payload.getData().body()).iterator().next()).getIdentifier(); final YangInstanceIdentifier node = payload.getInstanceIdentifierContext().getInstanceIdentifier().node(identifier); - doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, node.getParent(), payload.getData()); + doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, node.getParent(), payload.getData()); final DOMException domException = new DOMException((short) 414, "Post request failed"); - doReturn(immediateFailedFluentFuture(domException)).when(this.readWrite).commit(); - doReturn(immediateFailedFluentFuture(domException)).when(this.netconfService) + doReturn(immediateFailedFluentFuture(domException)).when(readWrite).commit(); + doReturn(immediateFailedFluentFuture(domException)).when(netconfService) .create(any(), any(), any(), any()); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).discardChanges(); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).unlock(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).discardChanges(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).unlock(); try { - PostDataTransactionUtil.postData(this.uriInfo, payload, - new MdsalRestconfStrategy(mockDataBroker), this.schema, null, null); + PostDataTransactionUtil.postData(uriInfo, payload, + new MdsalRestconfStrategy(mockDataBroker), schema, null, null); fail("Expected RestconfDocumentedException"); } catch (final RestconfDocumentedException e) { assertEquals(1, e.getErrors().size()); assertTrue(e.getErrors().get(0).getErrorInfo().contains(domException.getMessage())); } - verify(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iid2); - verify(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, + verify(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iid2); + verify(readWrite).put(LogicalDatastoreType.CONFIGURATION, payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData()); try { - PostDataTransactionUtil.postData(this.uriInfo, payload, - new NetconfRestconfStrategy(netconfService), this.schema, null, null); + PostDataTransactionUtil.postData(uriInfo, payload, + new NetconfRestconfStrategy(netconfService), schema, null, null); fail("Expected RestconfDocumentedException"); } catch (final RestconfDocumentedException e) { assertEquals(1, e.getErrors().size()); assertTrue(e.getErrors().get(0).getErrorInfo().contains(domException.getMessage())); } - verify(this.netconfService).create(LogicalDatastoreType.CONFIGURATION, + verify(netconfService).create(LogicalDatastoreType.CONFIGURATION, payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData(), Optional.empty()); } } 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 7f757efe5a..ab15d93f15 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 @@ -33,6 +33,7 @@ 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.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; @@ -80,7 +81,7 @@ public class PutDataTransactionUtilTest { @Before public void setUp() throws Exception { - this.schema = + 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"); @@ -94,35 +95,35 @@ public class PutDataTransactionUtilTest { final NodeIdentifierWithPredicates nodeWithKey2 = NodeIdentifierWithPredicates.of(listQname, listKeyQname, "name of band 2"); - final DataSchemaContextTree tree = DataSchemaContextTree.from(this.schema); - this.iid = YangInstanceIdentifier.builder() + final DataSchemaContextTree tree = DataSchemaContextTree.from(schema); + iid = YangInstanceIdentifier.builder() .node(baseQName) .node(containerQname) .node(leafQname) .build(); - this.schemaNode = tree.findChild(this.iid).orElseThrow().getDataSchemaNode(); + schemaNode = tree.findChild(iid).orElseThrow().getDataSchemaNode(); - this.iid2 = YangInstanceIdentifier.builder() + iid2 = YangInstanceIdentifier.builder() .node(baseQName) .build(); - this.schemaNode2 = tree.findChild(this.iid2).orElseThrow().getDataSchemaNode(); + schemaNode2 = tree.findChild(iid2).orElseThrow().getDataSchemaNode(); - this.iid3 = YangInstanceIdentifier.builder() + iid3 = YangInstanceIdentifier.builder() .node(baseQName) .node(listQname) .node(nodeWithKey) .build(); - this.schemaNode3 = tree.findChild(this.iid3).orElseThrow().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(); @@ -134,7 +135,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) @@ -154,237 +155,237 @@ 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(); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).lock(); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).unlock(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).lock(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).unlock(); } @Test public void testValidInputData() { final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iid, this.schemaNode, null, this.schema); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildLeaf); + new InstanceIdentifierContext<>(iid, schemaNode, null, schema); + final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, buildLeaf); RestconfDataServiceImpl.validInputData(iidContext.getSchemaNode(), payload); } @Test public void testValidTopLevelNodeName() { InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iid, this.schemaNode, null, this.schema); - NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildLeaf); + new InstanceIdentifierContext<>(iid, schemaNode, null, schema); + NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, buildLeaf); RestconfDataServiceImpl.validTopLevelNodeName(iidContext.getInstanceIdentifier(), payload); - iidContext = new InstanceIdentifierContext<>(this.iid2, this.schemaNode2, null, this.schema); - payload = new NormalizedNodeContext(iidContext, this.buildBaseCont); + iidContext = new InstanceIdentifierContext<>(iid2, schemaNode2, null, schema); + payload = new NormalizedNodeContext(iidContext, buildBaseCont); RestconfDataServiceImpl.validTopLevelNodeName(iidContext.getInstanceIdentifier(), payload); } @Test(expected = RestconfDocumentedException.class) public void testValidTopLevelNodeNamePathEmpty() { final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iid, this.schemaNode, null, this.schema); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildLeaf); + new InstanceIdentifierContext<>(iid, schemaNode, null, schema); + final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, buildLeaf); RestconfDataServiceImpl.validTopLevelNodeName(YangInstanceIdentifier.empty(), payload); } @Test(expected = RestconfDocumentedException.class) public void testValidTopLevelNodeNameWrongTopIdentifier() { final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iid, this.schemaNode, null, this.schema); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildLeaf); - RestconfDataServiceImpl.validTopLevelNodeName(this.iid.getAncestor(1), payload); + new InstanceIdentifierContext<>(iid, schemaNode, null, schema); + final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, buildLeaf); + RestconfDataServiceImpl.validTopLevelNodeName(iid.getAncestor(1), payload); } @Test public void testValidateListKeysEqualityInPayloadAndUri() { final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iid3, this.schemaNode3, null, this.schema); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildListEntry); + new InstanceIdentifierContext<>(iid3, schemaNode3, null, schema); + final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, buildListEntry); RestconfDataServiceImpl.validateListKeysEqualityInPayloadAndUri(payload); } @Test public void testPutContainerData() { final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iid2, this.schemaNode2, null, this.schema); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseCont); + new InstanceIdentifierContext<>(iid2, schemaNode2, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseCont); - doReturn(this.readWrite).when(this.mockDataBroker).newReadWriteTransaction(); - doReturn(this.read).when(this.mockDataBroker).newReadOnlyTransaction(); + doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction(); + doReturn(read).when(mockDataBroker).newReadOnlyTransaction(); doReturn(immediateFalseFluentFuture()) - .when(this.read).exists(LogicalDatastoreType.CONFIGURATION, this.iid2); - doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, + .when(read).exists(LogicalDatastoreType.CONFIGURATION, iid2); + doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData()); - doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit(); + doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit(); - PutDataTransactionUtil.putData(payload, this.schema, new MdsalRestconfStrategy(mockDataBroker), null, null); - verify(this.read).exists(LogicalDatastoreType.CONFIGURATION, + PutDataTransactionUtil.putData(payload, schema, new MdsalRestconfStrategy(mockDataBroker), null, null); + verify(read).exists(LogicalDatastoreType.CONFIGURATION, payload.getInstanceIdentifierContext().getInstanceIdentifier()); - verify(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, + verify(readWrite).put(LogicalDatastoreType.CONFIGURATION, payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData()); } @Test public void testPutCreateContainerData() { final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iid2, this.schemaNode2, null, this.schema); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseCont); + new InstanceIdentifierContext<>(iid2, schemaNode2, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseCont); - doReturn(immediateFluentFuture(Optional.empty())).when(this.netconfService).getConfig(this.iid2); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).commit(); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService) + 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, payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData(), Optional.empty()); - PutDataTransactionUtil.putData(payload, this.schema, new NetconfRestconfStrategy(netconfService), + PutDataTransactionUtil.putData(payload, schema, new NetconfRestconfStrategy(netconfService), null, null); - verify(this.netconfService).lock(); - verify(this.netconfService).getConfig(payload.getInstanceIdentifierContext().getInstanceIdentifier()); - verify(this.netconfService).replace(LogicalDatastoreType.CONFIGURATION, + verify(netconfService).lock(); + verify(netconfService).getConfig(payload.getInstanceIdentifierContext().getInstanceIdentifier()); + verify(netconfService).replace(LogicalDatastoreType.CONFIGURATION, payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData(), Optional.empty()); } @Test public void testPutReplaceContainerData() { final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iid2, this.schemaNode2, null, this.schema); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseCont); + new InstanceIdentifierContext<>(iid2, schemaNode2, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseCont); doReturn(immediateFluentFuture(Optional.of(mock(NormalizedNode.class)))) - .when(this.netconfService).getConfig(this.iid2); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).commit(); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService) + .when(netconfService).getConfig(iid2); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService) .replace(LogicalDatastoreType.CONFIGURATION, payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData(), Optional.empty()); - PutDataTransactionUtil.putData(payload, this.schema, new NetconfRestconfStrategy(netconfService), + PutDataTransactionUtil.putData(payload, schema, new NetconfRestconfStrategy(netconfService), null, null); - verify(this.netconfService).getConfig(payload.getInstanceIdentifierContext().getInstanceIdentifier()); - verify(this.netconfService).replace(LogicalDatastoreType.CONFIGURATION, + verify(netconfService).getConfig(payload.getInstanceIdentifierContext().getInstanceIdentifier()); + verify(netconfService).replace(LogicalDatastoreType.CONFIGURATION, payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData(), Optional.empty()); } @Test public void testPutLeafData() { final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iid, this.schemaNode, null, this.schema); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildLeaf); + new InstanceIdentifierContext<>(iid, schemaNode, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildLeaf); - doReturn(this.readWrite).when(this.mockDataBroker).newReadWriteTransaction(); - doReturn(this.read).when(this.mockDataBroker).newReadOnlyTransaction(); + doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction(); + doReturn(read).when(mockDataBroker).newReadOnlyTransaction(); doReturn(immediateFalseFluentFuture()) - .when(this.read).exists(LogicalDatastoreType.CONFIGURATION, this.iid); - doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, + .when(read).exists(LogicalDatastoreType.CONFIGURATION, iid); + doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData()); - doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit(); + doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit(); - PutDataTransactionUtil.putData(payload, this.schema, new MdsalRestconfStrategy(mockDataBroker), null, null); - verify(this.read).exists(LogicalDatastoreType.CONFIGURATION, + PutDataTransactionUtil.putData(payload, schema, new MdsalRestconfStrategy(mockDataBroker), null, null); + verify(read).exists(LogicalDatastoreType.CONFIGURATION, payload.getInstanceIdentifierContext().getInstanceIdentifier()); - verify(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, + verify(readWrite).put(LogicalDatastoreType.CONFIGURATION, payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData()); } @Test public void testPutCreateLeafData() { final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iid, this.schemaNode, null, this.schema); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildLeaf); + new InstanceIdentifierContext<>(iid, schemaNode, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildLeaf); - doReturn(immediateFluentFuture(Optional.empty())).when(this.netconfService).getConfig(this.iid); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).commit(); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService) + 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, payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData(), Optional.empty()); - PutDataTransactionUtil.putData(payload, this.schema, new NetconfRestconfStrategy(netconfService), + PutDataTransactionUtil.putData(payload, schema, new NetconfRestconfStrategy(netconfService), null, null); - verify(this.netconfService).getConfig(payload.getInstanceIdentifierContext().getInstanceIdentifier()); - verify(this.netconfService).replace(LogicalDatastoreType.CONFIGURATION, + verify(netconfService).getConfig(payload.getInstanceIdentifierContext().getInstanceIdentifier()); + verify(netconfService).replace(LogicalDatastoreType.CONFIGURATION, payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData(), Optional.empty()); } @Test public void testPutReplaceLeafData() { final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iid, this.schemaNode, null, this.schema); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildLeaf); + new InstanceIdentifierContext<>(iid, schemaNode, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildLeaf); doReturn(immediateFluentFuture(Optional.of(mock(NormalizedNode.class)))) - .when(this.netconfService).getConfig(this.iid); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).commit(); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService) + .when(netconfService).getConfig(iid); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService).commit(); + doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(netconfService) .replace(LogicalDatastoreType.CONFIGURATION, payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData(), Optional.empty()); - PutDataTransactionUtil.putData(payload, this.schema, + PutDataTransactionUtil.putData(payload, schema, new NetconfRestconfStrategy(netconfService), null, null); - verify(this.netconfService).getConfig(payload.getInstanceIdentifierContext().getInstanceIdentifier()); - verify(this.netconfService).replace(LogicalDatastoreType.CONFIGURATION, + verify(netconfService).getConfig(payload.getInstanceIdentifierContext().getInstanceIdentifier()); + verify(netconfService).replace(LogicalDatastoreType.CONFIGURATION, payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData(), Optional.empty()); } @Test public void testPutListData() { final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iid2, this.schemaNode2, null, this.schema); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseContWithList); + new InstanceIdentifierContext<>(iid2, schemaNode2, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseContWithList); - doReturn(this.readWrite).when(this.mockDataBroker).newReadWriteTransaction(); - doReturn(this.read).when(this.mockDataBroker).newReadOnlyTransaction(); + doReturn(readWrite).when(mockDataBroker).newReadWriteTransaction(); + doReturn(read).when(mockDataBroker).newReadOnlyTransaction(); doReturn(immediateFalseFluentFuture()) - .when(this.read).exists(LogicalDatastoreType.CONFIGURATION, this.iid2); - doNothing().when(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, + .when(read).exists(LogicalDatastoreType.CONFIGURATION, iid2); + doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, payload.getInstanceIdentifierContext().getInstanceIdentifier(), payload.getData()); - doReturn(CommitInfo.emptyFluentFuture()).when(this.readWrite).commit(); - PutDataTransactionUtil.putData(payload, this.schema, new MdsalRestconfStrategy(mockDataBroker), null, null); - verify(this.read).exists(LogicalDatastoreType.CONFIGURATION, this.iid2); - verify(this.readWrite).put(LogicalDatastoreType.CONFIGURATION, this.iid2, payload.getData()); + doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit(); + PutDataTransactionUtil.putData(payload, schema, new MdsalRestconfStrategy(mockDataBroker), null, null); + verify(read).exists(LogicalDatastoreType.CONFIGURATION, iid2); + verify(readWrite).put(LogicalDatastoreType.CONFIGURATION, iid2, payload.getData()); } @Test public void testPutCreateListData() { final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iid2, this.schemaNode2, null, this.schema); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseContWithList); + new InstanceIdentifierContext<>(iid2, schemaNode2, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseContWithList); - doReturn(immediateFluentFuture(Optional.empty())).when(this.netconfService) - .getConfig(this.iid2); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).commit(); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService) - .replace(LogicalDatastoreType.CONFIGURATION, this.iid2, payload.getData(), Optional.empty()); + 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, this.schema, new NetconfRestconfStrategy(netconfService), + PutDataTransactionUtil.putData(payload, schema, new NetconfRestconfStrategy(netconfService), null, null); - verify(this.netconfService).getConfig(this.iid2); - verify(this.netconfService).replace(LogicalDatastoreType.CONFIGURATION, this.iid2, + verify(netconfService).getConfig(iid2); + verify(netconfService).replace(LogicalDatastoreType.CONFIGURATION, iid2, payload.getData(), Optional.empty()); } @Test public void testPutReplaceListData() { final InstanceIdentifierContext iidContext = - new InstanceIdentifierContext<>(this.iid2, this.schemaNode2, null, this.schema); - final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildBaseContWithList); + new InstanceIdentifierContext<>(iid2, schemaNode2, null, schema); + final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, buildBaseContWithList); - doReturn(immediateFluentFuture(Optional.of(mock(NormalizedNode.class)))).when(this.netconfService) - .getConfig(this.iid2); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService).commit(); - doReturn(Futures.immediateFuture(new DefaultDOMRpcResult())).when(this.netconfService) + 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, - this.iid2, payload.getData(), Optional.empty()); + iid2, payload.getData(), Optional.empty()); - PutDataTransactionUtil.putData(payload, this.schema, + PutDataTransactionUtil.putData(payload, schema, new NetconfRestconfStrategy(netconfService), null, null); - verify(this.netconfService).getConfig(this.iid2); - verify(this.netconfService).replace(LogicalDatastoreType.CONFIGURATION, this.iid2, + verify(netconfService).getConfig(iid2); + verify(netconfService).replace(LogicalDatastoreType.CONFIGURATION, iid2, payload.getData(), Optional.empty()); } } diff --git a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/ReadDataTransactionUtilTest.java b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/ReadDataTransactionUtilTest.java index 9a7ebc65a6..85f7607a58 100644 --- a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/ReadDataTransactionUtilTest.java +++ b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/ReadDataTransactionUtilTest.java @@ -37,9 +37,9 @@ import org.opendaylight.mdsal.dom.api.DOMDataBroker; import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction; import org.opendaylight.netconf.dom.api.NetconfDataTreeService; import org.opendaylight.restconf.common.context.InstanceIdentifierContext; -import org.opendaylight.restconf.common.context.WriterParameters; import org.opendaylight.restconf.common.errors.RestconfDocumentedException; import org.opendaylight.restconf.common.errors.RestconfError; +import org.opendaylight.restconf.nb.rfc8040.legacy.QueryParameters; import org.opendaylight.restconf.nb.rfc8040.rests.transactions.MdsalRestconfStrategy; import org.opendaylight.restconf.nb.rfc8040.rests.transactions.NetconfRestconfStrategy; import org.opendaylight.restconf.nb.rfc8040.rests.transactions.RestconfStrategy; @@ -97,14 +97,14 @@ public class ReadDataTransactionUtilTest { DOMDataBroker mockDataBroker = mock(DOMDataBroker.class); doReturn(read).when(mockDataBroker).newReadOnlyTransaction(); mdsalStrategy = new MdsalRestconfStrategy(mockDataBroker); - netconfStrategy = new NetconfRestconfStrategy(this.netconfService); + netconfStrategy = new NetconfRestconfStrategy(netconfService); } @Test public void readDataConfigTest() { doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(read) .read(LogicalDatastoreType.CONFIGURATION, DATA.path); - doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(this.netconfService).getConfig(DATA.path); + doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(netconfService).getConfig(DATA.path); final String valueOfContent = RestconfDataServiceConstant.ReadData.CONFIG; NormalizedNode normalizedNode = readData(valueOfContent, DATA.path, mdsalStrategy); assertEquals(DATA.data3, normalizedNode); @@ -119,8 +119,8 @@ public class ReadDataTransactionUtilTest { .read(LogicalDatastoreType.CONFIGURATION, DATA.path); doReturn(immediateFluentFuture(Optional.empty())).when(read) .read(LogicalDatastoreType.OPERATIONAL, DATA.path); - doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(this.netconfService).getConfig(DATA.path); - doReturn(immediateFluentFuture(Optional.empty())).when(this.netconfService).get(DATA.path); + doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(netconfService).getConfig(DATA.path); + doReturn(immediateFluentFuture(Optional.empty())).when(netconfService).get(DATA.path); final String valueOfContent = RestconfDataServiceConstant.ReadData.ALL; NormalizedNode normalizedNode = readData(valueOfContent, DATA.path, mdsalStrategy); assertEquals(DATA.data3, normalizedNode); @@ -135,8 +135,8 @@ public class ReadDataTransactionUtilTest { .read(LogicalDatastoreType.OPERATIONAL, DATA.path2); doReturn(immediateFluentFuture(Optional.empty())).when(read) .read(LogicalDatastoreType.CONFIGURATION, DATA.path2); - doReturn(immediateFluentFuture(Optional.of(DATA.data2))).when(this.netconfService).get(DATA.path2); - doReturn(immediateFluentFuture(Optional.empty())).when(this.netconfService).getConfig(DATA.path2); + doReturn(immediateFluentFuture(Optional.of(DATA.data2))).when(netconfService).get(DATA.path2); + doReturn(immediateFluentFuture(Optional.empty())).when(netconfService).getConfig(DATA.path2); final String valueOfContent = RestconfDataServiceConstant.ReadData.ALL; NormalizedNode normalizedNode = readData(valueOfContent, DATA.path2, mdsalStrategy); assertEquals(DATA.data2, normalizedNode); @@ -149,7 +149,7 @@ public class ReadDataTransactionUtilTest { public void readDataNonConfigTest() { doReturn(immediateFluentFuture(Optional.of(DATA.data2))).when(read) .read(LogicalDatastoreType.OPERATIONAL, DATA.path2); - doReturn(immediateFluentFuture(Optional.of(DATA.data2))).when(this.netconfService).get(DATA.path2); + doReturn(immediateFluentFuture(Optional.of(DATA.data2))).when(netconfService).get(DATA.path2); final String valueOfContent = RestconfDataServiceConstant.ReadData.NONCONFIG; NormalizedNode normalizedNode = readData(valueOfContent, DATA.path2, mdsalStrategy); assertEquals(DATA.data2, normalizedNode); @@ -164,8 +164,8 @@ public class ReadDataTransactionUtilTest { .read(LogicalDatastoreType.CONFIGURATION, DATA.path); doReturn(immediateFluentFuture(Optional.of(DATA.data4))).when(read) .read(LogicalDatastoreType.OPERATIONAL, DATA.path); - doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(this.netconfService).getConfig(DATA.path); - doReturn(immediateFluentFuture(Optional.of(DATA.data4))).when(this.netconfService).get(DATA.path); + doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(netconfService).getConfig(DATA.path); + doReturn(immediateFluentFuture(Optional.of(DATA.data4))).when(netconfService).get(DATA.path); final String valueOfContent = RestconfDataServiceConstant.ReadData.ALL; final ContainerNode checkingData = Builders .containerBuilder() @@ -186,8 +186,8 @@ public class ReadDataTransactionUtilTest { .read(LogicalDatastoreType.CONFIGURATION, DATA.path); doReturn(immediateFluentFuture(Optional.of(DATA.data4))).when(read) .read(LogicalDatastoreType.OPERATIONAL, DATA.path); - doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(this.netconfService).getConfig(DATA.path); - doReturn(immediateFluentFuture(Optional.of(DATA.data4))).when(this.netconfService).get(DATA.path); + doReturn(immediateFluentFuture(Optional.of(DATA.data3))).when(netconfService).getConfig(DATA.path); + doReturn(immediateFluentFuture(Optional.of(DATA.data4))).when(netconfService).get(DATA.path); final ContainerNode checkingData = Builders .containerBuilder() .withNodeIdentifier(NODE_IDENTIFIER) @@ -207,8 +207,8 @@ public class ReadDataTransactionUtilTest { .read(LogicalDatastoreType.OPERATIONAL, DATA.path3); doReturn(immediateFluentFuture(Optional.of(DATA.listData2))).when(read) .read(LogicalDatastoreType.CONFIGURATION, DATA.path3); - doReturn(immediateFluentFuture(Optional.of(DATA.listData))).when(this.netconfService).get(DATA.path3); - doReturn(immediateFluentFuture(Optional.of(DATA.listData2))).when(this.netconfService).getConfig(DATA.path3); + doReturn(immediateFluentFuture(Optional.of(DATA.listData))).when(netconfService).get(DATA.path3); + doReturn(immediateFluentFuture(Optional.of(DATA.listData2))).when(netconfService).getConfig(DATA.path3); final String valueOfContent = RestconfDataServiceConstant.ReadData.ALL; final MapNode checkingData = Builders .mapBuilder() @@ -228,8 +228,8 @@ public class ReadDataTransactionUtilTest { .read(LogicalDatastoreType.OPERATIONAL, DATA.path3); doReturn(immediateFluentFuture(Optional.of(DATA.orderedMapNode2))).when(read) .read(LogicalDatastoreType.CONFIGURATION, DATA.path3); - doReturn(immediateFluentFuture(Optional.of(DATA.orderedMapNode1))).when(this.netconfService).get(DATA.path3); - doReturn(immediateFluentFuture(Optional.of(DATA.orderedMapNode2))).when(this.netconfService) + doReturn(immediateFluentFuture(Optional.of(DATA.orderedMapNode1))).when(netconfService).get(DATA.path3); + doReturn(immediateFluentFuture(Optional.of(DATA.orderedMapNode2))).when(netconfService) .getConfig(DATA.path3); final MapNode expectedData = Builders.orderedMapBuilder() .withNodeIdentifier(new NodeIdentifier(DATA.listQname)) @@ -249,8 +249,8 @@ public class ReadDataTransactionUtilTest { .read(LogicalDatastoreType.OPERATIONAL, DATA.path3); doReturn(immediateFluentFuture(Optional.of(DATA.unkeyedListNode2))).when(read) .read(LogicalDatastoreType.CONFIGURATION, DATA.path3); - doReturn(immediateFluentFuture(Optional.of(DATA.unkeyedListNode1))).when(this.netconfService).get(DATA.path3); - doReturn(immediateFluentFuture(Optional.of(DATA.unkeyedListNode2))).when(this.netconfService) + doReturn(immediateFluentFuture(Optional.of(DATA.unkeyedListNode1))).when(netconfService).get(DATA.path3); + doReturn(immediateFluentFuture(Optional.of(DATA.unkeyedListNode2))).when(netconfService) .getConfig(DATA.path3); final UnkeyedListNode expectedData = Builders.unkeyedListBuilder() .withNodeIdentifier(new NodeIdentifier(DATA.listQname)) @@ -271,9 +271,9 @@ public class ReadDataTransactionUtilTest { .read(LogicalDatastoreType.OPERATIONAL, DATA.leafSetNodePath); doReturn(immediateFluentFuture(Optional.of(DATA.leafSetNode2))).when(read) .read(LogicalDatastoreType.CONFIGURATION, DATA.leafSetNodePath); - doReturn(immediateFluentFuture(Optional.of(DATA.leafSetNode1))).when(this.netconfService) + doReturn(immediateFluentFuture(Optional.of(DATA.leafSetNode1))).when(netconfService) .get(DATA.leafSetNodePath); - doReturn(immediateFluentFuture(Optional.of(DATA.leafSetNode2))).when(this.netconfService) + doReturn(immediateFluentFuture(Optional.of(DATA.leafSetNode2))).when(netconfService) .getConfig(DATA.leafSetNodePath); final LeafSetNode expectedData = Builders.leafSetBuilder() .withNodeIdentifier(new NodeIdentifier(DATA.leafListQname)) @@ -296,9 +296,9 @@ public class ReadDataTransactionUtilTest { .read(LogicalDatastoreType.OPERATIONAL, DATA.leafSetNodePath); doReturn(immediateFluentFuture(Optional.of(DATA.orderedLeafSetNode2))).when(read) .read(LogicalDatastoreType.CONFIGURATION, DATA.leafSetNodePath); - doReturn(immediateFluentFuture(Optional.of(DATA.orderedLeafSetNode1))).when(this.netconfService) + doReturn(immediateFluentFuture(Optional.of(DATA.orderedLeafSetNode1))).when(netconfService) .get(DATA.leafSetNodePath); - doReturn(immediateFluentFuture(Optional.of(DATA.orderedLeafSetNode2))).when(this.netconfService) + doReturn(immediateFluentFuture(Optional.of(DATA.orderedLeafSetNode2))).when(netconfService) .getConfig(DATA.leafSetNodePath); final LeafSetNode expectedData = Builders.orderedLeafSetBuilder() .withNodeIdentifier(new NodeIdentifier(DATA.leafListQname)) @@ -319,7 +319,7 @@ public class ReadDataTransactionUtilTest { public void readDataWrongPathOrNoContentTest() { doReturn(immediateFluentFuture(Optional.empty())).when(read) .read(LogicalDatastoreType.CONFIGURATION, DATA.path2); - doReturn(immediateFluentFuture(Optional.empty())).when(this.netconfService).getConfig(DATA.path2); + doReturn(immediateFluentFuture(Optional.empty())).when(netconfService).getConfig(DATA.path2); final String valueOfContent = RestconfDataServiceConstant.ReadData.CONFIG; NormalizedNode normalizedNode = readData(valueOfContent, DATA.path2, mdsalStrategy); assertNull(normalizedNode); @@ -349,7 +349,7 @@ public class ReadDataTransactionUtilTest { // no parameters, default values should be used when(uriInfo.getQueryParameters()).thenReturn(parameters); - final WriterParameters parsedParameters = ReadDataTransactionUtil.parseUriParameters(context, uriInfo); + final QueryParameters parsedParameters = ReadDataTransactionUtil.parseUriParameters(context, uriInfo); assertEquals("Not correctly parsed URI parameter", RestconfDataServiceConstant.ReadData.ALL, parsedParameters.getContent()); @@ -377,7 +377,7 @@ public class ReadDataTransactionUtilTest { when(uriInfo.getQueryParameters()).thenReturn(parameters); - final WriterParameters parsedParameters = ReadDataTransactionUtil.parseUriParameters(context, uriInfo); + final QueryParameters parsedParameters = ReadDataTransactionUtil.parseUriParameters(context, uriInfo); // content assertEquals("Not correctly parsed URI parameter", @@ -488,7 +488,7 @@ public class ReadDataTransactionUtilTest { parameters.put(RestconfDataServiceConstant.ReadData.WITH_DEFAULTS, List.of("explicit")); when(uriInfo.getQueryParameters()).thenReturn(parameters); - final WriterParameters writerParameters = ReadDataTransactionUtil.parseUriParameters(context, uriInfo); + final QueryParameters writerParameters = ReadDataTransactionUtil.parseUriParameters(context, uriInfo); assertSame(WithDefaults.EXPLICIT.value(), writerParameters.getWithDefault()); assertFalse(writerParameters.isTagged()); } @@ -524,7 +524,7 @@ public class ReadDataTransactionUtilTest { List.of(ReadData.WithDefaults.REPORT_ALL_TAGGED.value())); when(uriInfo.getQueryParameters()).thenReturn(parameters); - final WriterParameters writerParameters = ReadDataTransactionUtil.parseUriParameters(context, uriInfo); + final QueryParameters writerParameters = ReadDataTransactionUtil.parseUriParameters(context, uriInfo); assertNull(writerParameters.getWithDefault()); assertTrue(writerParameters.isTagged()); } @@ -542,7 +542,7 @@ public class ReadDataTransactionUtilTest { List.of(ReadData.WithDefaults.REPORT_ALL.value())); when(uriInfo.getQueryParameters()).thenReturn(parameters); - final WriterParameters writerParameters = ReadDataTransactionUtil.parseUriParameters(context, uriInfo); + final QueryParameters writerParameters = ReadDataTransactionUtil.parseUriParameters(context, uriInfo); assertNull(writerParameters.getWithDefault()); assertFalse(writerParameters.isTagged()); } -- 2.36.6