*/
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<Set<QName>> fields;
- private final List<YangInstanceIdentifier> 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<Set<QName>> getFields() {
- return fields;
- }
-
- public List<YangInstanceIdentifier> getFieldPaths() {
- return fieldPaths;
- }
-
public boolean isPrettyPrint() {
return prettyPrint;
}
return tagged;
}
- public String getWithDefault() {
- return withDefault;
- }
-
public static class WriterParametersBuilder {
- private String content;
private Integer depth;
- private List<Set<QName>> fields;
- private List<YangInstanceIdentifier> 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<Set<QName>> fields) {
- this.fields = fields;
- return this;
- }
-
- public WriterParametersBuilder setFieldPaths(final List<YangInstanceIdentifier> 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);
}
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;
// Hidden on purpose
}
- public static @NonNull NormalizedNodeContext contextForModelContext(final @NonNull SchemaContext context,
- final @Nullable DOMMountPoint mountPoint) {
+ public static @NonNull Entry<InstanceIdentifierContext<OperationsContainerSchemaNode>, 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<Module> modules = new ArrayList<>();
final ArrayList<OperationsLeafSchemaNode> rpcLeafSchemas = new ArrayList<>();
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());
}
}
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() {
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<NormalizedNodeContext> {
+abstract class AbstractNormalizedNodeBodyReader extends AbstractIdentifierAwareJaxRsProvider<NormalizedNodePayload> {
AbstractNormalizedNodeBodyReader(final SchemaContextHandler schemaContextHandler,
final DOMMountPointService mountPointService) {
super(schemaContextHandler, mountPointService);
}
@Override
- protected final NormalizedNodeContext emptyBody(final InstanceIdentifierContext<?> path) {
- return new NormalizedNodeContext(path, null);
+ protected final NormalizedNodePayload emptyBody(final InstanceIdentifierContext<?> path) {
+ return NormalizedNodePayload.empty(path);
}
}
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<NormalizedNodeContext> {
+abstract class AbstractNormalizedNodeBodyWriter implements MessageBodyWriter<NormalizedNodePayload> {
@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);
}
}
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;
@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());
}
}
- 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);
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 {
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;
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,
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;
@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);
}
}
- 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;
final InstanceIdentifierContext<? extends SchemaNode> 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<Object> findPathToSchemaNodeByName(final DataSchemaNode schemaNode, final String elementName,
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;
}
@Override
- public void writeTo(final NormalizedNodeContext context,
+ public void writeTo(final NormalizedNodePayload context,
final Class<?> type,
final Type genericType,
final Annotation[] annotations,
--- /dev/null
+/*
+ * 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<String, Object> 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();
+ }
+}
--- /dev/null
+/*
+ * 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<YangInstanceIdentifier> fieldPaths;
+ private List<Set<QName>> 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<Set<QName>> fields) {
+ this.fields = fields;
+ return this;
+ }
+
+ public Builder setFieldPaths(final List<YangInstanceIdentifier> 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<YangInstanceIdentifier> fieldPaths;
+ private final List<Set<QName>> 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<Set<QName>> getFields() {
+ return fields;
+ }
+
+ public List<YangInstanceIdentifier> getFieldPaths() {
+ return fieldPaths;
+ }
+
+ public String getWithDefault() {
+ return withDefault;
+ }
+}
--- /dev/null
+/*
+ * 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.
+ *
+ * <p>
+ * 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
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
* path to target
* @param uriInfo
* URI info
- * @return {@link NormalizedNodeContext}
+ * @return {@link NormalizedNodePayload}
*/
@GET
@Path("/data/{identifier:.+}")
*
* @param uriInfo
* URI info
- * @return {@link NormalizedNodeContext}
+ * @return {@link NormalizedNodePayload}
*/
@GET
@Path("/data")
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);
/**
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);
/**
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.
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);
}
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
* 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:.+}")
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);
}
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.
*
* @param identifier path parameter
* @param uriInfo URI information
- * @return {@link NormalizedNodeContext}
+ * @return {@link NormalizedNodePayload}
*/
@GET
@Path("/operations/{identifier:.+}")
MediaType.APPLICATION_XML,
MediaType.TEXT_XML
})
- NormalizedNodeContext getOperations(@PathParam("identifier") String identifier, @Context UriInfo uriInfo);
+ NormalizedNodePayload getOperations(@PathParam("identifier") String identifier, @Context UriInfo uriInfo);
}
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.
/**
* Get yang library version.
*
- * @return {@link NormalizedNodeContext}
+ * @return {@link NormalizedNodePayload}
*/
@GET
@Path("/yang-library-version")
MediaType.APPLICATION_XML,
MediaType.TEXT_XML
})
- NormalizedNodeContext getLibraryVersion();
+ NormalizedNodePayload getLibraryVersion();
}
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.
* 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);
}
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;
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();
}
@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);
}
@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);
}
@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<? extends SchemaNode> iid = payload.getInstanceIdentifierContext();
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;
}
@Override
- public NormalizedNodeContext getLibraryVersion() {
+ public NormalizedNodePayload getLibraryVersion() {
final EffectiveModelContext context = schemaContextHandler.get();
// FIXME: why are we going through a grouping here?!
(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()));
}
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;
}
@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();
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;
}
@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;
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) {
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;
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;
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;
}
@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;
}
// 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);
}
/**
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;
* @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) {
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;
* @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) {
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;
* @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();
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;
*
* @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();
}
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;
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;
@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<String, String>()).when(this.uriInfo).getQueryParameters();
- doReturn(immediateFluentFuture(Optional.of(this.buildBaseCont))).when(this.read)
- .read(LogicalDatastoreType.CONFIGURATION, this.iidBase);
+ doReturn(new MultivaluedHashMap<String, String>()).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<String, String>()).when(this.uriInfo).getQueryParameters();
- doReturn(immediateFluentFuture(Optional.of(wrapNodeByDataRootContainer(this.buildBaseContConfig))))
- .when(this.read)
+ doReturn(new MultivaluedHashMap<String, String>()).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());
*/
@Test
public void testReadDataMountPoint() {
- doReturn(new MultivaluedHashMap<String, String>()).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<String, String>()).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());
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<String, String>()).when(this.uriInfo).getQueryParameters();
+ doReturn(new MultivaluedHashMap<String, String>()).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);
}
/**
final MultivaluedHashMap<String, String> 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());
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());
}
/**
final MultivaluedHashMap<String, String> 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());
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<DataSchemaNode> 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());
}
@Test
public void testPutDataWithMountPoint() {
final InstanceIdentifierContext<DataSchemaNode> 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<Object> content = Builders.leafBuilder()
- .withNodeIdentifier(new NodeIdentifier(QName.create(this.baseQName, "name")))
- .withValue("name of band")
- .build();
- final LeafNode<Object> 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<String, String>()).when(this.uriInfo).getQueryParameters();
+ doReturn(new MultivaluedHashMap<String, String>()).when(uriInfo).getQueryParameters();
final InstanceIdentifierContext<? extends SchemaNode> 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());
}
*/
@Test
public void testDeleteDataMountPoint() {
- doNothing().when(this.readWrite).delete(LogicalDatastoreType.CONFIGURATION, this.iidBase);
+ doNothing().when(readWrite).delete(LogicalDatastoreType.CONFIGURATION, iidBase);
doReturn(immediateTrueFluentFuture())
- .when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, this.iidBase);
+ .when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iidBase);
final Response response =
- this.dataService.deleteData("example-jukebox:jukebox/yang-ext:mount/example-jukebox:jukebox");
+ dataService.deleteData("example-jukebox:jukebox/yang-ext:mount/example-jukebox:jukebox");
assertNotNull(response);
assertEquals(Response.Status.NO_CONTENT.getStatusCode(), response.getStatus());
}
@Test
public void testPatchData() {
final InstanceIdentifierContext<? extends SchemaNode> iidContext =
- new InstanceIdentifierContext<>(this.iidBase, this.schemaNode, null, this.contextRef);
+ new InstanceIdentifierContext<>(iidBase, schemaNode, null, contextRef);
final List<PatchEntity> 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());
@Test
public void testPatchDataMountPoint() throws Exception {
final InstanceIdentifierContext<? extends SchemaNode> iidContext = new InstanceIdentifierContext<>(
- this.iidBase, this.schemaNode, this.mountPoint, this.contextRef);
+ iidBase, schemaNode, mountPoint, contextRef);
final List<PatchEntity> 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());
@Test
public void testPatchDataDeleteNotExist() {
final InstanceIdentifierContext<? extends SchemaNode> iidContext =
- new InstanceIdentifierContext<>(this.iidBase, this.schemaNode, null, this.contextRef);
+ new InstanceIdentifierContext<>(iidBase, schemaNode, null, contextRef);
final List<PatchEntity> 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());
@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);
}
}
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;
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
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");
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);
}
}
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;
@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");
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();
.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<DataSchemaNode> 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<DataSchemaNode> 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<DataSchemaNode> 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());
}
}
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;
@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");
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();
.withNodeIdentifier(new NodeIdentifier(containerQname))
.withChild(buildLeaf)
.build();
- this.buildBaseCont = Builders.containerBuilder()
+ buildBaseCont = Builders.containerBuilder()
.withNodeIdentifier(new NodeIdentifier(baseQName))
.withChild(buildPlayerCont)
.build();
.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<? extends SchemaNode> 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<? extends SchemaNode> 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<? extends SchemaNode> 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());
}
}
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;
@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");
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();
.withNodeIdentifier(new NodeIdentifier(QName.create(baseQName, "description")))
.withValue("band description")
.build();
- this.buildListEntry = Builders.mapEntryBuilder()
+ buildListEntry = Builders.mapEntryBuilder()
.withNodeIdentifier(nodeWithKey)
.withChild(content)
.withChild(content2)
.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<DataSchemaNode> 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<DataSchemaNode> 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<DataSchemaNode> 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<DataSchemaNode> 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<DataSchemaNode> 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<DataSchemaNode> 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<DataSchemaNode> 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<DataSchemaNode> 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<DataSchemaNode> 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<DataSchemaNode> 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<DataSchemaNode> 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<DataSchemaNode> 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<DataSchemaNode> 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<DataSchemaNode> 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());
}
}
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;
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);
.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);
.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);
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);
.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()
.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)
.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()
.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))
.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))
.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<String> expectedData = Builders.<String>leafSetBuilder()
.withNodeIdentifier(new NodeIdentifier(DATA.leafListQname))
.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<String> expectedData = Builders.<String>orderedLeafSetBuilder()
.withNodeIdentifier(new NodeIdentifier(DATA.leafListQname))
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);
// 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());
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",
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());
}
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());
}
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());
}
Code Review / netconf.git / commitdiff