From 959d0adb82d69e18b4507a9010167c59c9b6cd46 Mon Sep 17 00:00:00 2001 From: Robert Varga Date: Thu, 28 Mar 2019 20:42:16 +0100 Subject: [PATCH] Bump yangtools to 3.0.0 This bumps yangtools to 3.0.0, adjusting by API changes introduced in this release: - EffectiveModelContextFactory is required by yang.model.repo.api constructs - JSONParserStream.create() deprecated methods removed - ParserConfigurationException no longer thrown from UntrustedXML - strict if-feature validation by YANG parser - SchemaUtils.getNodeIdentifierForAugmentation() removal - LeafrefSchemaNode correctly using PathExpression and not the overly-general RevisionAwareXPath - NormalizedNodeStreamWriter updates - NormalizedNodes no longer having attributes The last two items require a complete overhaul of how edit operation is disassembled in EditOperationNormalizedNodeStreamWriter. This is addressed in a follow-up patch. Change-Id: Ic58c7392d6326bc785bc2f1da9f5dee866e830dc Signed-off-by: Robert Varga --- features/netconf/odl-netconf-api/pom.xml | 2 +- .../src/main/feature/feature.xml | 2 +- features/netconf/odl-netconf-util/pom.xml | 2 +- .../src/main/feature/feature.xml | 2 +- features/restconf/odl-restconf-common/pom.xml | 2 +- .../src/main/feature/feature.xml | 2 +- .../impl/actors/NetconfNodeActor.java | 16 +- .../impl/utils/NetconfTopologyUtils.java | 11 +- .../singleton/impl/NetconfNodeActorTest.java | 44 ++--- .../topology/AbstractNetconfTopology.java | 12 +- .../netconf/util/StreamingContext.java | 16 +- .../netconf/LibraryModulesSchemas.java | 11 +- .../mapping/NetconfMessageTransformer.java | 11 +- .../util/NetconfMessageTransformUtil.java | 21 +- .../resources/schemas/config-test-rpc.yang | 5 + .../test/tool/NetconfDeviceSimulator.java | 5 +- .../impl/DepthAwareNormalizedNodeWriter.java | 48 ++--- .../RestconfDocumentedExceptionMapper.java | 56 +++++- .../impl/XmlNormalizedNodeBodyReader.java | 6 +- .../DepthAwareNormalizedNodeWriterTest.java | 179 ++++++++++-------- .../ParameterAwareNormalizedNodeWriter.java | 48 ++--- .../XmlNormalizedNodeBodyReader.java | 8 +- .../simple/impl/FakeRestconfModule.java | 6 - ...terAwareNormalizedNodeWriterDepthTest.java | 177 +++++++++-------- ...erAwareNormalizedNodeWriterFieldsTest.java | 11 +- ...areNormalizedNodeWriterParametersTest.java | 12 +- .../sal/rest/doc/impl/ModelGenerator.java | 10 +- 27 files changed, 386 insertions(+), 339 deletions(-) diff --git a/features/netconf/odl-netconf-api/pom.xml b/features/netconf/odl-netconf-api/pom.xml index 0e54b54cdb..fed8f9fd7f 100644 --- a/features/netconf/odl-netconf-api/pom.xml +++ b/features/netconf/odl-netconf-api/pom.xml @@ -28,7 +28,7 @@ org.opendaylight.yangtools yangtools-artifacts - 2.1.8 + 3.0.0 pom import diff --git a/features/netconf/odl-netconf-api/src/main/feature/feature.xml b/features/netconf/odl-netconf-api/src/main/feature/feature.xml index d69c4534e1..323c3ac014 100644 --- a/features/netconf/odl-netconf-api/src/main/feature/feature.xml +++ b/features/netconf/odl-netconf-api/src/main/feature/feature.xml @@ -9,6 +9,6 @@ odl-netty-4 - odl-yangtools-parser-api + odl-yangtools-parser-api diff --git a/features/netconf/odl-netconf-util/pom.xml b/features/netconf/odl-netconf-util/pom.xml index ab4cc899c7..be9989cb54 100644 --- a/features/netconf/odl-netconf-util/pom.xml +++ b/features/netconf/odl-netconf-util/pom.xml @@ -38,7 +38,7 @@ org.opendaylight.yangtools odl-yangtools-codec - 2.1.8 + 3.0.0 xml features diff --git a/features/netconf/odl-netconf-util/src/main/feature/feature.xml b/features/netconf/odl-netconf-util/src/main/feature/feature.xml index 1181590451..a14c497738 100644 --- a/features/netconf/odl-netconf-util/src/main/feature/feature.xml +++ b/features/netconf/odl-netconf-util/src/main/feature/feature.xml @@ -11,6 +11,6 @@ mvn:org.opendaylight.netconf/netconf-util/${project.version}/cfg/config - odl-yangtools-codec + odl-yangtools-codec diff --git a/features/restconf/odl-restconf-common/pom.xml b/features/restconf/odl-restconf-common/pom.xml index ff53d645c7..4aff4f5f85 100644 --- a/features/restconf/odl-restconf-common/pom.xml +++ b/features/restconf/odl-restconf-common/pom.xml @@ -28,7 +28,7 @@ org.opendaylight.yangtools yangtools-artifacts - 2.1.8 + 3.0.0 pom import diff --git a/features/restconf/odl-restconf-common/src/main/feature/feature.xml b/features/restconf/odl-restconf-common/src/main/feature/feature.xml index b73fc254e7..79b29cb689 100644 --- a/features/restconf/odl-restconf-common/src/main/feature/feature.xml +++ b/features/restconf/odl-restconf-common/src/main/feature/feature.xml @@ -9,6 +9,6 @@ odl-karaf-feat-jetty - odl-yangtools-export + odl-yangtools-export diff --git a/netconf/netconf-topology-singleton/src/main/java/org/opendaylight/netconf/topology/singleton/impl/actors/NetconfNodeActor.java b/netconf/netconf-topology-singleton/src/main/java/org/opendaylight/netconf/topology/singleton/impl/actors/NetconfNodeActor.java index 1234ee778b..7f8ff7d836 100644 --- a/netconf/netconf-topology-singleton/src/main/java/org/opendaylight/netconf/topology/singleton/impl/actors/NetconfNodeActor.java +++ b/netconf/netconf-topology-singleton/src/main/java/org/opendaylight/netconf/topology/singleton/impl/actors/NetconfNodeActor.java @@ -54,11 +54,11 @@ import org.opendaylight.netconf.topology.singleton.messages.transactions.NewRead import org.opendaylight.netconf.topology.singleton.messages.transactions.NewReadWriteTransactionRequest; import org.opendaylight.netconf.topology.singleton.messages.transactions.NewWriteTransactionRequest; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; +import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.model.api.SchemaPath; -import org.opendaylight.yangtools.yang.model.repo.api.SchemaContextFactory; +import org.opendaylight.yangtools.yang.model.repo.api.EffectiveModelContextFactory; import org.opendaylight.yangtools.yang.model.repo.api.SchemaRepository; -import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceFilter; import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier; import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource; import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource; @@ -67,7 +67,6 @@ import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceRegistry; import scala.concurrent.duration.Duration; public class NetconfNodeActor extends AbstractUntypedActor { - private final Duration writeTxIdleTimeout; private final DOMMountPointService mountPointService; @@ -272,7 +271,7 @@ public class NetconfNodeActor extends AbstractUntypedActor { return new ProxyDOMRpcService(setup.getActorSystem(), masterReference, id, actorResponseWaitTime); } - private SchemaContextFactory createSchemaContextFactory(final ActorRef masterReference) { + private EffectiveModelContextFactory createSchemaContextFactory(final ActorRef masterReference) { final RemoteYangTextSourceProvider remoteYangTextSourceProvider = new ProxyYangTextSourceProvider(masterReference, getContext().dispatcher(), actorResponseWaitTime); final RemoteSchemaProvider remoteProvider = new RemoteSchemaProvider(remoteYangTextSourceProvider, @@ -284,13 +283,13 @@ public class NetconfNodeActor extends AbstractUntypedActor { YangTextSchemaSource.class, PotentialSchemaSource.Costs.REMOTE_IO.getValue()))) .collect(Collectors.toList()); - return schemaRepository.createSchemaContextFactory(SchemaSourceFilter.ALWAYS_ACCEPT); + return schemaRepository.createEffectiveModelContextFactory(); } - private void resolveSchemaContext(final SchemaContextFactory schemaContextFactory, + private void resolveSchemaContext(final EffectiveModelContextFactory schemaContextFactory, final SlaveSalFacade localSlaveSalManager, final ActorRef masterReference, final int tries) { - final ListenableFuture schemaContextFuture = - schemaContextFactory.createSchemaContext(sourceIdentifiers); + final ListenableFuture schemaContextFuture = + schemaContextFactory.createEffectiveModelContext(sourceIdentifiers); Futures.addCallback(schemaContextFuture, new FutureCallback() { @Override public void onSuccess(final SchemaContext result) { @@ -335,5 +334,4 @@ public class NetconfNodeActor extends AbstractUntypedActor { registeredSchemas = null; } } - } diff --git a/netconf/netconf-topology-singleton/src/main/java/org/opendaylight/netconf/topology/singleton/impl/utils/NetconfTopologyUtils.java b/netconf/netconf-topology-singleton/src/main/java/org/opendaylight/netconf/topology/singleton/impl/utils/NetconfTopologyUtils.java index 1b7cd2be30..48cf059149 100644 --- a/netconf/netconf-topology-singleton/src/main/java/org/opendaylight/netconf/topology/singleton/impl/utils/NetconfTopologyUtils.java +++ b/netconf/netconf-topology-singleton/src/main/java/org/opendaylight/netconf/topology/singleton/impl/utils/NetconfTopologyUtils.java @@ -32,9 +32,8 @@ import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology. import org.opendaylight.yangtools.yang.binding.Identifier; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier; -import org.opendaylight.yangtools.yang.model.repo.api.SchemaContextFactory; +import org.opendaylight.yangtools.yang.model.repo.api.EffectiveModelContextFactory; import org.opendaylight.yangtools.yang.model.repo.api.SchemaRepository; -import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceFilter; import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource; import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceRegistry; import org.opendaylight.yangtools.yang.model.repo.util.FilesystemSchemaSourceCache; @@ -80,8 +79,8 @@ public final class NetconfTopologyUtils { InMemorySchemaSourceCache.createSoftCache(DEFAULT_SCHEMA_REPOSITORY, ASTSchemaSource.class); // The default factory for creating SchemaContext instances. - public static final SchemaContextFactory DEFAULT_SCHEMA_CONTEXT_FACTORY = - DEFAULT_SCHEMA_REPOSITORY.createSchemaContextFactory(SchemaSourceFilter.ALWAYS_ACCEPT); + public static final EffectiveModelContextFactory DEFAULT_SCHEMA_CONTEXT_FACTORY = + DEFAULT_SCHEMA_REPOSITORY.createEffectiveModelContextFactory(); /** * Keeps track of initialized Schema resources. A Map is maintained in which the key represents the name @@ -184,8 +183,8 @@ public final class NetconfTopologyUtils { */ private static NetconfDevice.SchemaResourcesDTO createSchemaResourcesDTO(final String moduleSchemaCacheDirectory) { final SharedSchemaRepository repository = new SharedSchemaRepository(moduleSchemaCacheDirectory); - final SchemaContextFactory schemaContextFactory - = repository.createSchemaContextFactory(SchemaSourceFilter.ALWAYS_ACCEPT); + final EffectiveModelContextFactory schemaContextFactory + = repository.createEffectiveModelContextFactory(); final FilesystemSchemaSourceCache deviceCache = createDeviceFilesystemCache(moduleSchemaCacheDirectory, repository); diff --git a/netconf/netconf-topology-singleton/src/test/java/org/opendaylight/netconf/topology/singleton/impl/NetconfNodeActorTest.java b/netconf/netconf-topology-singleton/src/test/java/org/opendaylight/netconf/topology/singleton/impl/NetconfNodeActorTest.java index 4f79e46c1a..145140011e 100644 --- a/netconf/netconf-topology-singleton/src/test/java/org/opendaylight/netconf/topology/singleton/impl/NetconfNodeActorTest.java +++ b/netconf/netconf-topology-singleton/src/test/java/org/opendaylight/netconf/topology/singleton/impl/NetconfNodeActorTest.java @@ -12,6 +12,7 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyCollection; import static org.mockito.ArgumentMatchers.argThat; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.after; @@ -90,14 +91,14 @@ import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; 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.model.api.EffectiveModelContext; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.model.repo.api.EffectiveModelContextFactory; import org.opendaylight.yangtools.yang.model.repo.api.MissingSchemaSourceException; import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier; -import org.opendaylight.yangtools.yang.model.repo.api.SchemaContextFactory; import org.opendaylight.yangtools.yang.model.repo.api.SchemaRepository; import org.opendaylight.yangtools.yang.model.repo.api.SchemaResolutionException; -import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceFilter; import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier; import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource; import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource; @@ -150,13 +151,13 @@ public class NetconfNodeActorTest { private SchemaSourceRegistry mockRegistry; @Mock - private SchemaContextFactory mockSchemaContextFactory; + private EffectiveModelContextFactory mockSchemaContextFactory; @Mock private SchemaRepository mockSchemaRepository; @Mock - private SchemaContext mockSchemaContext; + private EffectiveModelContext mockSchemaContext; @Before public void setup() { @@ -184,7 +185,7 @@ public class NetconfNodeActorTest { doReturn(mockSchemaSourceReg2).when(mockRegistry).registerSchemaSource(any(), withSourceId(SOURCE_IDENTIFIER2)); doReturn(mockSchemaContextFactory).when(mockSchemaRepository) - .createSchemaContextFactory(any(SchemaSourceFilter.class)); + .createEffectiveModelContextFactory(); } @After @@ -258,13 +259,13 @@ public class NetconfNodeActorTest { doReturn(mockSchemaSourceReg1).when(mockRegistry).registerSchemaSource(any(), withSourceId(SOURCE_IDENTIFIER1)); doReturn(mockSchemaContextFactory).when(mockSchemaRepository) - .createSchemaContextFactory(any(SchemaSourceFilter.class)); + .createEffectiveModelContextFactory(); final SchemaSourceRegistration newMockSchemaSourceReg = mock(SchemaSourceRegistration.class); - final SchemaContextFactory newMockSchemaContextFactory = mock(SchemaContextFactory.class); + final EffectiveModelContextFactory newMockSchemaContextFactory = mock(EffectiveModelContextFactory.class); doReturn(Futures.immediateFuture(mockSchemaContext)) - .when(newMockSchemaContextFactory).createSchemaContext(any()); + .when(newMockSchemaContextFactory).createEffectiveModelContext(anyCollection()); doAnswer(unused -> { SettableFuture future = SettableFuture.create(); @@ -273,7 +274,7 @@ public class NetconfNodeActorTest { withSourceId(SOURCE_IDENTIFIER1)); doReturn(newMockSchemaContextFactory).when(mockSchemaRepository) - .createSchemaContextFactory(any(SchemaSourceFilter.class)); + .createEffectiveModelContextFactory(); slaveRef.tell(new RegisterMountPoint(ImmutableList.of(SOURCE_IDENTIFIER1), masterRef), testKit.getRef()); @@ -281,10 +282,10 @@ public class NetconfNodeActorTest { future.set(mockSchemaContext); }).start(); return future; - }).when(mockSchemaContextFactory).createSchemaContext(any()); + }).when(mockSchemaContextFactory).createEffectiveModelContext(anyCollection()); doReturn(mockSchemaContextFactory).when(mockSchemaRepository) - .createSchemaContextFactory(any(SchemaSourceFilter.class)); + .createEffectiveModelContextFactory(); slaveRef.tell(new RegisterMountPoint(ImmutableList.of(SOURCE_IDENTIFIER1), masterRef), testKit.getRef()); @@ -295,7 +296,7 @@ public class NetconfNodeActorTest { verify(mockMountPointBuilder).addService(eq(DOMNotificationService.class), any()); verify(mockSchemaSourceReg1).close(); verify(mockRegistry, times(2)).registerSchemaSource(any(), withSourceId(SOURCE_IDENTIFIER1)); - verify(mockSchemaRepository, times(2)).createSchemaContextFactory(any(SchemaSourceFilter.class)); + verify(mockSchemaRepository, times(2)).createEffectiveModelContextFactory(); verifyNoMoreInteractions(mockMountPointBuilder, newMockSchemaSourceReg); // Stop the slave actor and verify schema source registrations are closed. @@ -318,7 +319,7 @@ public class NetconfNodeActorTest { // Test unrecoverable failure. doReturn(Futures.immediateFailedFuture(new SchemaResolutionException("mock"))) - .when(mockSchemaContextFactory).createSchemaContext(any()); + .when(mockSchemaContextFactory).createEffectiveModelContext(anyCollection()); slaveRef.tell(new RegisterMountPoint(ImmutableList.of(SOURCE_IDENTIFIER1, SOURCE_IDENTIFIER2), masterRef), testKit.getRef()); @@ -339,7 +340,7 @@ public class NetconfNodeActorTest { doReturn(Futures.immediateFailedFuture(new SchemaResolutionException("mock", new AskTimeoutException("timeout")))) .doReturn(Futures.immediateFuture(mockSchemaContext)) - .when(mockSchemaContextFactory).createSchemaContext(any()); + .when(mockSchemaContextFactory).createEffectiveModelContext(anyCollection()); slaveRef.tell(new RegisterMountPoint(ImmutableList.of(SOURCE_IDENTIFIER1, SOURCE_IDENTIFIER2), masterRef), testKit.getRef()); @@ -355,15 +356,15 @@ public class NetconfNodeActorTest { reset(mockSchemaSourceReg1, mockSchemaSourceReg2, mockSchemaRepository, mockSchemaContextFactory); resetMountPointMocks(); - final SchemaContextFactory mockSchemaContextFactorySuccess = mock(SchemaContextFactory.class); + final EffectiveModelContextFactory mockSchemaContextFactorySuccess = mock(EffectiveModelContextFactory.class); doReturn(Futures.immediateFuture(mockSchemaContext)) - .when(mockSchemaContextFactorySuccess).createSchemaContext(any()); + .when(mockSchemaContextFactorySuccess).createEffectiveModelContext(anyCollection()); doAnswer(unused -> { SettableFuture future = SettableFuture.create(); new Thread(() -> { doReturn(mockSchemaContextFactorySuccess).when(mockSchemaRepository) - .createSchemaContextFactory(any(SchemaSourceFilter.class)); + .createEffectiveModelContextFactory(); slaveRef.tell(new RegisterMountPoint(ImmutableList.of(SOURCE_IDENTIFIER1, SOURCE_IDENTIFIER2), masterRef), testKit.getRef()); @@ -371,16 +372,15 @@ public class NetconfNodeActorTest { future.setException(new SchemaResolutionException("mock", new AskTimeoutException("timeout"))); }).start(); return future; - }).when(mockSchemaContextFactory).createSchemaContext(any()); + }).when(mockSchemaContextFactory).createEffectiveModelContext(anyCollection()); - doReturn(mockSchemaContextFactory).when(mockSchemaRepository) - .createSchemaContextFactory(any(SchemaSourceFilter.class)); + doReturn(mockSchemaContextFactory).when(mockSchemaRepository).createEffectiveModelContextFactory(); slaveRef.tell(new RegisterMountPoint(ImmutableList.of(SOURCE_IDENTIFIER1, SOURCE_IDENTIFIER2), masterRef), testKit.getRef()); verify(mockMountPointBuilder, timeout(5000)).register(); - verify(mockSchemaRepository, times(2)).createSchemaContextFactory(any(SchemaSourceFilter.class)); + verify(mockSchemaRepository, times(2)).createEffectiveModelContextFactory(); } @Test @@ -527,7 +527,7 @@ public class NetconfNodeActorTest { mockSchemaRepository, TIMEOUT, mockMountPointService)); doReturn(Futures.immediateFuture(mockSchemaContext)) - .when(mockSchemaContextFactory).createSchemaContext(any()); + .when(mockSchemaContextFactory).createEffectiveModelContext(anyCollection()); slaveRef.tell(new RegisterMountPoint(ImmutableList.of(SOURCE_IDENTIFIER1, SOURCE_IDENTIFIER2), masterRef), testKit.getRef()); diff --git a/netconf/netconf-topology/src/main/java/org/opendaylight/netconf/topology/AbstractNetconfTopology.java b/netconf/netconf-topology/src/main/java/org/opendaylight/netconf/topology/AbstractNetconfTopology.java index 9bb24504a8..513693ff96 100644 --- a/netconf/netconf-topology/src/main/java/org/opendaylight/netconf/topology/AbstractNetconfTopology.java +++ b/netconf/netconf-topology/src/main/java/org/opendaylight/netconf/topology/AbstractNetconfTopology.java @@ -80,9 +80,10 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev15 import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.credentials.credentials.login.pw.unencrypted.LoginPasswordUnencrypted; import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId; import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node; +import org.opendaylight.yangtools.yang.model.repo.api.EffectiveModelContextFactory; import org.opendaylight.yangtools.yang.model.repo.api.SchemaContextFactory; +import org.opendaylight.yangtools.yang.model.repo.api.SchemaContextFactoryConfiguration; import org.opendaylight.yangtools.yang.model.repo.api.SchemaRepository; -import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceFilter; import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier; import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource; import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource; @@ -144,8 +145,9 @@ public abstract class AbstractNetconfTopology implements NetconfTopology { /** * The default factory for creating SchemaContext instances. */ - private static final SchemaContextFactory DEFAULT_SCHEMA_CONTEXT_FACTORY = - DEFAULT_SCHEMA_REPOSITORY.createSchemaContextFactory(SchemaSourceFilter.ALWAYS_ACCEPT); + private static final EffectiveModelContextFactory DEFAULT_SCHEMA_CONTEXT_FACTORY = + DEFAULT_SCHEMA_REPOSITORY.createEffectiveModelContextFactory( + SchemaContextFactoryConfiguration.getDefault()); /** * Keeps track of initialized Schema resources. A Map is maintained in which the key represents the name @@ -444,8 +446,8 @@ public abstract class AbstractNetconfTopology implements NetconfTopology { */ private NetconfDevice.SchemaResourcesDTO createSchemaResourcesDTO(final String moduleSchemaCacheDirectory) { final SharedSchemaRepository repository = new SharedSchemaRepository(moduleSchemaCacheDirectory); - final SchemaContextFactory contextFactory - = repository.createSchemaContextFactory(SchemaSourceFilter.ALWAYS_ACCEPT); + final EffectiveModelContextFactory contextFactory + = repository.createEffectiveModelContextFactory(SchemaContextFactoryConfiguration.getDefault()); setSchemaRegistry(repository); setSchemaContextFactory(contextFactory); final FilesystemSchemaSourceCache deviceCache = diff --git a/netconf/netconf-util/src/main/java/org/opendaylight/netconf/util/StreamingContext.java b/netconf/netconf-util/src/main/java/org/opendaylight/netconf/util/StreamingContext.java index e1393609a5..c4240e2338 100644 --- a/netconf/netconf-util/src/main/java/org/opendaylight/netconf/util/StreamingContext.java +++ b/netconf/netconf-util/src/main/java/org/opendaylight/netconf/util/StreamingContext.java @@ -243,7 +243,9 @@ abstract class StreamingContext implements Identifiable< @Override void streamToWriter(final NormalizedNodeStreamWriter writer, final PathArgument first, final Iterator others) throws IOException { - writer.anyxmlNode(getIdentifier(), null); + writer.startAnyxmlNode(getIdentifier()); + // FIXME: why are we not emitting a value? + writer.endNode(); } } @@ -287,7 +289,9 @@ abstract class StreamingContext implements Identifiable< @Override void streamToWriter(final NormalizedNodeStreamWriter writer, final PathArgument first, final Iterator others) throws IOException { - writer.leafNode(getIdentifier(), null); + writer.startLeafNode(getIdentifier()); + // FIXME: why are we not emitting a value? + writer.endNode(); } } @@ -301,7 +305,9 @@ abstract class StreamingContext implements Identifiable< final Iterator others) throws IOException { checkArgument(first instanceof NodeWithValue); final NodeWithValue identifier = (NodeWithValue) first; - writer.leafSetEntryNode(identifier.getNodeType(), identifier.getValue()); + writer.startLeafSetEntryNode(identifier); + writer.scalarValue(identifier.getValue()); + writer.endNode(); } } @@ -321,7 +327,9 @@ abstract class StreamingContext implements Identifiable< writer.startMapEntryNode(identifier, UNKNOWN_SIZE); for (Entry entry : identifier.getKeyValues().entrySet()) { - writer.leafNode(new NodeIdentifier(entry.getKey()), entry.getValue()); + writer.startLeafNode(new NodeIdentifier(entry.getKey())); + writer.scalarValue(entry.getValue()); + writer.endNode(); } } } diff --git a/netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/LibraryModulesSchemas.java b/netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/LibraryModulesSchemas.java index 9b0b0f268c..8b06c5f89f 100644 --- a/netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/LibraryModulesSchemas.java +++ b/netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/LibraryModulesSchemas.java @@ -38,7 +38,6 @@ import java.util.Set; import java.util.concurrent.ExecutionException; import java.util.regex.Pattern; import javax.xml.parsers.DocumentBuilder; -import javax.xml.parsers.ParserConfigurationException; import javax.xml.stream.XMLStreamException; import javax.xml.transform.dom.DOMSource; import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext; @@ -60,6 +59,8 @@ import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode; import org.opendaylight.yangtools.yang.data.api.schema.MapNode; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter; +import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactory; +import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactorySupplier; import org.opendaylight.yangtools.yang.data.codec.gson.JsonParserStream; import org.opendaylight.yangtools.yang.data.codec.xml.XmlParserStream; import org.opendaylight.yangtools.yang.data.impl.schema.Builders; @@ -92,6 +93,9 @@ public final class LibraryModulesSchemas implements NetconfDeviceSchemas { LIBRARY_CONTEXT = moduleInfoBackedContext.tryToCreateSchemaContext().get(); } + private static final JSONCodecFactory JSON_CODECS = JSONCodecFactorySupplier.DRAFT_LHOTKA_NETMOD_YANG_JSON_02 + .getShared(LIBRARY_CONTEXT); + private final Map availableModels; private static final YangInstanceIdentifier MODULES_STATE_MODULE_LIST = @@ -303,7 +307,7 @@ public final class LibraryModulesSchemas implements NetconfDeviceSchemas { final NormalizedNodeResult resultHolder = new NormalizedNodeResult(); final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder); - final JsonParserStream jsonParser = JsonParserStream.create(writer, LIBRARY_CONTEXT); + final JsonParserStream jsonParser = JsonParserStream.create(writer, JSON_CODECS); final JsonReader reader = new JsonReader(new InputStreamReader(in, Charset.defaultCharset())); jsonParser.parse(reader); @@ -339,8 +343,7 @@ public final class LibraryModulesSchemas implements NetconfDeviceSchemas { xmlParser.traverse(new DOMSource(doc.getDocumentElement())); final NormalizedNode parsed = resultHolder.getResult(); return Optional.of(parsed); - } catch (XMLStreamException | URISyntaxException | IOException | ParserConfigurationException - | SAXException e) { + } catch (XMLStreamException | URISyntaxException | IOException | SAXException e) { LOG.warn("Unable to parse yang library xml content", e); } diff --git a/netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/schema/mapping/NetconfMessageTransformer.java b/netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/schema/mapping/NetconfMessageTransformer.java index 2523f2e409..7559b4c4d8 100644 --- a/netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/schema/mapping/NetconfMessageTransformer.java +++ b/netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/schema/mapping/NetconfMessageTransformer.java @@ -25,7 +25,6 @@ import java.util.Collection; import java.util.Collections; import java.util.Map; import java.util.Set; -import javax.xml.parsers.ParserConfigurationException; import javax.xml.stream.XMLStreamException; import javax.xml.transform.dom.DOMResult; import javax.xml.transform.dom.DOMSource; @@ -155,8 +154,8 @@ public class NetconfMessageTransformer implements MessageTransformer SUBTREE_FILTER_ATTRIBUTES = ImmutableMap.of(NETCONF_TYPE_QNAME, SUBTREE); public static final DataContainerChild EMPTY_FILTER; static { - final NormalizedNodeAttrBuilder anyXmlBuilder = - Builders.anyXmlBuilder().withNodeIdentifier(NETCONF_FILTER_NODEID) - .withAttributes(SUBTREE_FILTER_ATTRIBUTES); - final Element element = XmlUtil.createElement(BLANK_DOCUMENT, NETCONF_FILTER_QNAME.getLocalName(), Optional.of(NETCONF_FILTER_QNAME.getNamespace().toString())); element.setAttributeNS(NETCONF_FILTER_QNAME.getNamespace().toString(), - NETCONF_TYPE_QNAME.getLocalName(), "subtree"); - - anyXmlBuilder.withValue(new DOMSource(element)); + NETCONF_TYPE_QNAME.getLocalName(), SUBTREE); - EMPTY_FILTER = anyXmlBuilder.build(); + EMPTY_FILTER = Builders.anyXmlBuilder().withNodeIdentifier(NETCONF_FILTER_NODEID) + .withValue(new DOMSource(element)).build(); } public static DataContainerChild toFilterStructure(final YangInstanceIdentifier identifier, final SchemaContext ctx) { - final NormalizedNodeAttrBuilder anyXmlBuilder = Builders.anyXmlBuilder() - .withNodeIdentifier(NETCONF_FILTER_NODEID).withAttributes(SUBTREE_FILTER_ATTRIBUTES); final Element element = XmlUtil.createElement(BLANK_DOCUMENT, NETCONF_FILTER_QNAME.getLocalName(), Optional.of(NETCONF_FILTER_QNAME.getNamespace().toString())); element.setAttributeNS(NETCONF_FILTER_QNAME.getNamespace().toString(), NETCONF_TYPE_QNAME.getLocalName(), - "subtree"); + SUBTREE); try { NetconfUtil.writeFilter(identifier, new DOMResult(element), SchemaPath.ROOT, ctx); } catch (IOException | XMLStreamException e) { throw new IllegalStateException("Unable to serialize filter element for path " + identifier, e); } - anyXmlBuilder.withValue(new DOMSource(element)); - return anyXmlBuilder.build(); + return Builders.anyXmlBuilder().withNodeIdentifier(NETCONF_FILTER_NODEID).withValue(new DOMSource(element)) + .build(); } public static void checkValidReply(final NetconfMessage input, final NetconfMessage output) diff --git a/netconf/sal-netconf-connector/src/test/resources/schemas/config-test-rpc.yang b/netconf/sal-netconf-connector/src/test/resources/schemas/config-test-rpc.yang index a64f3b8830..941a13de69 100644 --- a/netconf/sal-netconf-connector/src/test/resources/schemas/config-test-rpc.yang +++ b/netconf/sal-netconf-connector/src/test/resources/schemas/config-test-rpc.yang @@ -40,6 +40,11 @@ module config-test-rpc { if this attribute is present."; } + feature candidate; + feature startup; + feature writable-running; + feature url; + rpc edit-config { description "The operation loads all or part of a specified configuration to the specified target configuration."; diff --git a/netconf/tools/netconf-testtool/src/main/java/org/opendaylight/netconf/test/tool/NetconfDeviceSimulator.java b/netconf/tools/netconf-testtool/src/main/java/org/opendaylight/netconf/test/tool/NetconfDeviceSimulator.java index 35625ab30e..d75cf7b367 100644 --- a/netconf/tools/netconf-testtool/src/main/java/org/opendaylight/netconf/test/tool/NetconfDeviceSimulator.java +++ b/netconf/tools/netconf-testtool/src/main/java/org/opendaylight/netconf/test/tool/NetconfDeviceSimulator.java @@ -62,7 +62,6 @@ import org.opendaylight.yangtools.yang.common.Revision; import org.opendaylight.yangtools.yang.model.api.Module; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier; -import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceFilter; import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceRepresentation; import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier; import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource; @@ -325,8 +324,8 @@ public class NetconfDeviceSimulator implements Closeable { try { //necessary for creating mdsal data stores and operations - this.schemaContext = consumer.createSchemaContextFactory(SchemaSourceFilter.ALWAYS_ACCEPT) - .createSchemaContext(loadedSources).get(); + this.schemaContext = consumer.createEffectiveModelContextFactory() + .createEffectiveModelContext(loadedSources).get(); } catch (final InterruptedException | ExecutionException e) { throw new RuntimeException("Cannot parse schema context", e); } diff --git a/restconf/restconf-nb-bierman02/src/main/java/org/opendaylight/netconf/sal/rest/impl/DepthAwareNormalizedNodeWriter.java b/restconf/restconf-nb-bierman02/src/main/java/org/opendaylight/netconf/sal/rest/impl/DepthAwareNormalizedNodeWriter.java index 9374f13e49..aebc6531a7 100644 --- a/restconf/restconf-nb-bierman02/src/main/java/org/opendaylight/netconf/sal/rest/impl/DepthAwareNormalizedNodeWriter.java +++ b/restconf/restconf-nb-bierman02/src/main/java/org/opendaylight/netconf/sal/rest/impl/DepthAwareNormalizedNodeWriter.java @@ -33,7 +33,6 @@ import org.opendaylight.yangtools.yang.data.api.schema.OrderedLeafSetNode; import org.opendaylight.yangtools.yang.data.api.schema.OrderedMapNode; import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode; import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode; -import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamAttributeWriter; import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -140,26 +139,22 @@ public class DepthAwareNormalizedNodeWriter implements RestconfNormalizedNodeWri if (node instanceof LeafSetEntryNode) { if (currentDepth < maxDepth) { final LeafSetEntryNode nodeAsLeafList = (LeafSetEntryNode) node; - if (writer instanceof NormalizedNodeStreamAttributeWriter) { - ((NormalizedNodeStreamAttributeWriter) writer).leafSetEntryNode(nodeAsLeafList.getNodeType(), - nodeAsLeafList.getValue(), nodeAsLeafList.getAttributes()); - } else { - writer.leafSetEntryNode(nodeAsLeafList.getNodeType(), nodeAsLeafList.getValue()); - } + writer.startLeafSetEntryNode(nodeAsLeafList.getIdentifier()); + writer.scalarValue(nodeAsLeafList.getValue()); + writer.endNode(); } return true; } else if (node instanceof LeafNode) { final LeafNode nodeAsLeaf = (LeafNode)node; - if (writer instanceof NormalizedNodeStreamAttributeWriter) { - ((NormalizedNodeStreamAttributeWriter) writer) - .leafNode(nodeAsLeaf.getIdentifier(), nodeAsLeaf.getValue(), nodeAsLeaf.getAttributes()); - } else { - writer.leafNode(nodeAsLeaf.getIdentifier(), nodeAsLeaf.getValue()); - } + writer.startLeafNode(nodeAsLeaf.getIdentifier()); + writer.scalarValue(nodeAsLeaf.getValue()); + writer.endNode(); return true; } else if (node instanceof AnyXmlNode) { final AnyXmlNode anyXmlNode = (AnyXmlNode)node; - writer.anyxmlNode(anyXmlNode.getIdentifier(), anyXmlNode.getValue()); + writer.startAnyxmlNode(anyXmlNode.getIdentifier()); + writer.domSourceValue(anyXmlNode.getValue()); + writer.endNode(); return true; } @@ -194,19 +189,16 @@ public class DepthAwareNormalizedNodeWriter implements RestconfNormalizedNodeWri private void writeOnlyKeys(final Map keyValues) throws IllegalArgumentException, IOException { for (final Map.Entry entry : keyValues.entrySet()) { - writer.leafNode(new NodeIdentifier(entry.getKey()), entry.getValue()); + writer.startLeafNode(new NodeIdentifier(entry.getKey())); + writer.scalarValue(entry.getValue()); + writer.endNode(); } writer.endNode(); } protected boolean writeMapEntryNode(final MapEntryNode node) throws IOException { - if (writer instanceof NormalizedNodeStreamAttributeWriter) { - ((NormalizedNodeStreamAttributeWriter) writer) - .startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue()), node.getAttributes()); - } else { - writer.startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue())); - } + writer.startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue())); currentDepth++; writeMapEntryChildren(node); currentDepth--; @@ -217,12 +209,7 @@ public class DepthAwareNormalizedNodeWriter implements RestconfNormalizedNodeWri boolean processedAsCompositeNode = false; if (node instanceof ContainerNode) { final ContainerNode n = (ContainerNode) node; - if (writer instanceof NormalizedNodeStreamAttributeWriter) { - ((NormalizedNodeStreamAttributeWriter) writer) - .startContainerNode(n.getIdentifier(), childSizeHint(n.getValue()), n.getAttributes()); - } else { - writer.startContainerNode(n.getIdentifier(), childSizeHint(n.getValue())); - } + writer.startContainerNode(n.getIdentifier(), childSizeHint(n.getValue())); currentDepth++; processedAsCompositeNode = writeChildren(n.getValue()); currentDepth--; @@ -279,12 +266,7 @@ public class DepthAwareNormalizedNodeWriter implements RestconfNormalizedNodeWri @Override protected boolean writeMapEntryNode(final MapEntryNode node) throws IOException { final NormalizedNodeStreamWriter writer = getWriter(); - if (writer instanceof NormalizedNodeStreamAttributeWriter) { - ((NormalizedNodeStreamAttributeWriter) writer) - .startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue()), node.getAttributes()); - } else { - writer.startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue())); - } + writer.startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue())); final Set qnames = node.getIdentifier().getKeyValues().keySet(); // Write out all the key children diff --git a/restconf/restconf-nb-bierman02/src/main/java/org/opendaylight/netconf/sal/rest/impl/RestconfDocumentedExceptionMapper.java b/restconf/restconf-nb-bierman02/src/main/java/org/opendaylight/netconf/sal/rest/impl/RestconfDocumentedExceptionMapper.java index 5561949f5e..2bdd87701d 100644 --- a/restconf/restconf-nb-bierman02/src/main/java/org/opendaylight/netconf/sal/rest/impl/RestconfDocumentedExceptionMapper.java +++ b/restconf/restconf-nb-bierman02/src/main/java/org/opendaylight/netconf/sal/rest/impl/RestconfDocumentedExceptionMapper.java @@ -244,18 +244,38 @@ public class RestconfDocumentedExceptionMapper implements ExceptionMapper(leafSetEntryNodeQName, leafSetEntryNodeValue); - Mockito.when(leafSetEntryNodeData.getIdentifier()).thenReturn(leafSetEntryNodeIdentifier); - Mockito.when(leafSetEntryNodeData.getNodeType()).thenReturn(leafSetEntryNodeQName); + when(leafSetEntryNodeData.getIdentifier()).thenReturn(leafSetEntryNodeIdentifier); leafSetNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "leaf-set")); - Mockito.when(leafSetNodeData.getIdentifier()).thenReturn(leafSetNodeIdentifier); + when(leafSetNodeData.getIdentifier()).thenReturn(leafSetNodeIdentifier); final QName mapEntryNodeKey = QName.create("namespace", "key-field"); keyLeafNodeIdentifier = NodeIdentifier.create(mapEntryNodeKey); @@ -94,32 +97,32 @@ public class DepthAwareNormalizedNodeWriterTest { mapEntryNodeIdentifier = new YangInstanceIdentifier.NodeIdentifierWithPredicates( QName.create("namespace", "list-entry"), Collections.singletonMap(mapEntryNodeKey, keyLeafNodeValue)); - Mockito.when(mapEntryNodeData.getIdentifier()).thenReturn(mapEntryNodeIdentifier); - Mockito.when(mapEntryNodeData.getChild(keyLeafNodeIdentifier)).thenReturn(Optional.of(keyLeafNodeData)); + when(mapEntryNodeData.getIdentifier()).thenReturn(mapEntryNodeIdentifier); + when(mapEntryNodeData.getChild(keyLeafNodeIdentifier)).thenReturn(Optional.of(keyLeafNodeData)); - Mockito.when(keyLeafNodeData.getValue()).thenReturn(keyLeafNodeValue); - Mockito.when(keyLeafNodeData.getIdentifier()).thenReturn(keyLeafNodeIdentifier); + when(keyLeafNodeData.getValue()).thenReturn(keyLeafNodeValue); + when(keyLeafNodeData.getIdentifier()).thenReturn(keyLeafNodeIdentifier); anotherLeafNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "another-field")); anotherLeafNodeValue = "another-value"; - Mockito.when(anotherLeafNodeData.getValue()).thenReturn(anotherLeafNodeValue); - Mockito.when(anotherLeafNodeData.getIdentifier()).thenReturn(anotherLeafNodeIdentifier); + when(anotherLeafNodeData.getValue()).thenReturn(anotherLeafNodeValue); + when(anotherLeafNodeData.getIdentifier()).thenReturn(anotherLeafNodeIdentifier); // values - Mockito.when(leafSetEntryNodeData.getValue()).thenReturn(leafSetEntryNodeValue); + when(leafSetEntryNodeData.getValue()).thenReturn(leafSetEntryNodeValue); leafSetNodeValue = Collections.singletonList(leafSetEntryNodeData); - Mockito.when(leafSetNodeData.getValue()).thenReturn(leafSetNodeValue); + when(leafSetNodeData.getValue()).thenReturn(leafSetNodeValue); containerNodeValue = Collections.singleton(leafSetNodeData); - Mockito.when(containerNodeData.getValue()).thenReturn(containerNodeValue); + when(containerNodeData.getValue()).thenReturn(containerNodeValue); mapEntryNodeValue = Sets.newHashSet(keyLeafNodeData, anotherLeafNodeData); - Mockito.when(mapEntryNodeData.getValue()).thenReturn(mapEntryNodeValue); + when(mapEntryNodeData.getValue()).thenReturn(mapEntryNodeValue); mapNodeValue = Collections.singleton(mapEntryNodeData); - Mockito.when(mapNodeData.getValue()).thenReturn(mapNodeValue); + when(mapNodeData.getValue()).thenReturn(mapNodeValue); } /** @@ -131,10 +134,10 @@ public class DepthAwareNormalizedNodeWriterTest { depthWriter.write(containerNodeData); - final InOrder inOrder = Mockito.inOrder(writer); - inOrder.verify(writer, Mockito.times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size()); - inOrder.verify(writer, Mockito.times(1)).endNode(); - Mockito.verifyNoMoreInteractions(writer); + final InOrder inOrder = inOrder(writer); + inOrder.verify(writer, times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size()); + inOrder.verify(writer, times(1)).endNode(); + verifyNoMoreInteractions(writer); } /** @@ -147,13 +150,13 @@ public class DepthAwareNormalizedNodeWriterTest { depthWriter.write(containerNodeData); - final InOrder inOrder = Mockito.inOrder(writer); - inOrder.verify(writer, Mockito.times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size()); - inOrder.verify(writer, Mockito.times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size()); - inOrder.verify(writer, Mockito.times(1)).leafSetEntryNode( - leafSetEntryNodeIdentifier.getNodeType(), leafSetEntryNodeValue); - inOrder.verify(writer, Mockito.times(2)).endNode(); - Mockito.verifyNoMoreInteractions(writer); + final InOrder inOrder = inOrder(writer); + inOrder.verify(writer, times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size()); + inOrder.verify(writer, times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size()); + inOrder.verify(writer, times(1)).startLeafSetEntryNode(leafSetEntryNodeIdentifier); + inOrder.verify(writer, times(1)).scalarValue(leafSetEntryNodeValue); + inOrder.verify(writer, times(3)).endNode(); + verifyNoMoreInteractions(writer); } /** @@ -165,12 +168,13 @@ public class DepthAwareNormalizedNodeWriterTest { depthWriter.write(mapNodeData); - final InOrder inOrder = Mockito.inOrder(writer); - inOrder.verify(writer, Mockito.times(1)).startMapNode(mapNodeIdentifier, mapNodeValue.size()); - inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size()); - inOrder.verify(writer, Mockito.times(1)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue); - inOrder.verify(writer, Mockito.times(2)).endNode(); - Mockito.verifyNoMoreInteractions(writer); + final InOrder inOrder = inOrder(writer); + inOrder.verify(writer, times(1)).startMapNode(mapNodeIdentifier, mapNodeValue.size()); + inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size()); + inOrder.verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier); + inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue); + inOrder.verify(writer, times(3)).endNode(); + verifyNoMoreInteractions(writer); } /** @@ -187,14 +191,21 @@ public class DepthAwareNormalizedNodeWriterTest { depthWriter.write(mapNodeData); - final InOrder inOrder = Mockito.inOrder(writer); - inOrder.verify(writer, Mockito.times(1)).startMapNode(mapNodeIdentifier, mapNodeValue.size()); - inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size()); - inOrder.verify(writer, Mockito.times(2)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue); + final InOrder inOrder = inOrder(writer); + inOrder.verify(writer, times(1)).startMapNode(mapNodeIdentifier, mapNodeValue.size()); + inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size()); + inOrder.verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier); + inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue); + inOrder.verify(writer, times(1)).endNode(); + inOrder.verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier); + inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue); + inOrder.verify(writer, times(1)).endNode(); + // FIXME this assertion is not working because leaves are not written in expected order - inOrder.verify(writer, Mockito.times(1)).leafNode(anotherLeafNodeIdentifier, anotherLeafNodeValue); - inOrder.verify(writer, Mockito.times(2)).endNode(); - Mockito.verifyNoMoreInteractions(writer); + inOrder.verify(writer, times(1)).startLeafNode(anotherLeafNodeIdentifier); + inOrder.verify(writer, times(1)).scalarValue(anotherLeafNodeValue); + inOrder.verify(writer, times(3)).endNode(); + verifyNoMoreInteractions(writer); } /** @@ -207,10 +218,10 @@ public class DepthAwareNormalizedNodeWriterTest { depthWriter.write(leafSetNodeData); - final InOrder inOrder = Mockito.inOrder(writer); - inOrder.verify(writer, Mockito.times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size()); - inOrder.verify(writer, Mockito.times(1)).endNode(); - Mockito.verifyNoMoreInteractions(writer); + final InOrder inOrder = inOrder(writer); + inOrder.verify(writer, times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size()); + inOrder.verify(writer, times(1)).endNode(); + verifyNoMoreInteractions(writer); } /** @@ -223,12 +234,12 @@ public class DepthAwareNormalizedNodeWriterTest { depthWriter.write(leafSetNodeData); - final InOrder inOrder = Mockito.inOrder(writer); - inOrder.verify(writer, Mockito.times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size()); - inOrder.verify(writer, Mockito.times(1)).leafSetEntryNode( - leafSetEntryNodeIdentifier.getNodeType(), leafSetEntryNodeValue); - inOrder.verify(writer, Mockito.times(1)).endNode(); - Mockito.verifyNoMoreInteractions(writer); + final InOrder inOrder = inOrder(writer); + inOrder.verify(writer, times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size()); + inOrder.verify(writer, times(1)).startLeafSetEntryNode(leafSetEntryNodeIdentifier); + inOrder.verify(writer, times(1)).scalarValue(leafSetEntryNodeValue); + inOrder.verify(writer, times(2)).endNode(); + verifyNoMoreInteractions(writer); } /** @@ -241,10 +252,11 @@ public class DepthAwareNormalizedNodeWriterTest { depthWriter.write(leafSetEntryNodeData); - final InOrder inOrder = Mockito.inOrder(writer); - inOrder.verify(writer, Mockito.times(1)).leafSetEntryNode( - leafSetEntryNodeIdentifier.getNodeType(), leafSetEntryNodeValue); - Mockito.verifyNoMoreInteractions(writer); + final InOrder inOrder = inOrder(writer); + inOrder.verify(writer, times(1)).startLeafSetEntryNode(leafSetEntryNodeIdentifier); + inOrder.verify(writer, times(1)).scalarValue(leafSetEntryNodeValue); + inOrder.verify(writer, times(1)).endNode(); + verifyNoMoreInteractions(writer); } /** @@ -257,12 +269,13 @@ public class DepthAwareNormalizedNodeWriterTest { depthWriter.write(mapEntryNodeData); - final InOrder inOrder = Mockito.inOrder(writer); - inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size()); + final InOrder inOrder = inOrder(writer); + inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size()); // write only the key - inOrder.verify(writer, Mockito.times(1)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue); - inOrder.verify(writer, Mockito.times(1)).endNode(); - Mockito.verifyNoMoreInteractions(writer); + inOrder.verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier); + inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue); + inOrder.verify(writer, times(2)).endNode(); + verifyNoMoreInteractions(writer); } /** @@ -276,11 +289,13 @@ public class DepthAwareNormalizedNodeWriterTest { depthWriter.write(mapEntryNodeData); // unordered - Mockito.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size()); - Mockito.verify(writer, Mockito.times(1)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue); - Mockito.verify(writer, Mockito.times(1)).leafNode(anotherLeafNodeIdentifier, anotherLeafNodeValue); - Mockito.verify(writer, Mockito.times(1)).endNode(); - Mockito.verifyNoMoreInteractions(writer); + verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size()); + verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier); + verify(writer, times(1)).scalarValue(keyLeafNodeValue); + verify(writer, times(1)).startLeafNode(anotherLeafNodeIdentifier); + verify(writer, times(1)).scalarValue(anotherLeafNodeValue); + verify(writer, times(3)).endNode(); + verifyNoMoreInteractions(writer); } /** @@ -293,11 +308,12 @@ public class DepthAwareNormalizedNodeWriterTest { depthWriter.write(mapEntryNodeData); - final InOrder inOrder = Mockito.inOrder(writer); - inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size()); - inOrder.verify(writer, Mockito.times(1)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue); - inOrder.verify(writer, Mockito.times(1)).endNode(); - Mockito.verifyNoMoreInteractions(writer); + final InOrder inOrder = inOrder(writer); + inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size()); + inOrder.verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier); + inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue); + inOrder.verify(writer, times(2)).endNode(); + verifyNoMoreInteractions(writer); } /** @@ -314,12 +330,15 @@ public class DepthAwareNormalizedNodeWriterTest { depthWriter.write(mapEntryNodeData); - final InOrder inOrder = Mockito.inOrder(writer); - inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size()); - inOrder.verify(writer, Mockito.times(2)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue); + final InOrder inOrder = inOrder(writer); + inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size()); + inOrder.verify(writer, times(2)).startLeafNode(keyLeafNodeIdentifier); + inOrder.verify(writer, times(2)).scalarValue(keyLeafNodeValue); + inOrder.verify(writer, times(1)).endNode(); // FIXME this assertion is not working because leaves are not written in expected order - inOrder.verify(writer, Mockito.times(1)).leafNode(anotherLeafNodeIdentifier, anotherLeafNodeValue); - inOrder.verify(writer, Mockito.times(1)).endNode(); - Mockito.verifyNoMoreInteractions(writer); + inOrder.verify(writer, times(1)).startLeafNode(anotherLeafNodeIdentifier); + inOrder.verify(writer, times(2)).scalarValue(anotherLeafNodeValue); + inOrder.verify(writer, times(2)).endNode(); + verifyNoMoreInteractions(writer); } } \ No newline at end of file diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/ParameterAwareNormalizedNodeWriter.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/ParameterAwareNormalizedNodeWriter.java index be8d9ce391..d7a4cc6ebb 100644 --- a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/ParameterAwareNormalizedNodeWriter.java +++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/ParameterAwareNormalizedNodeWriter.java @@ -36,7 +36,6 @@ import org.opendaylight.yangtools.yang.data.api.schema.OrderedLeafSetNode; import org.opendaylight.yangtools.yang.data.api.schema.OrderedMapNode; import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode; import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode; -import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamAttributeWriter; import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -153,26 +152,22 @@ public class ParameterAwareNormalizedNodeWriter implements RestconfNormalizedNod if (node instanceof LeafSetEntryNode) { if (selectedByParameters(node, false)) { final LeafSetEntryNode nodeAsLeafList = (LeafSetEntryNode) node; - if (writer instanceof NormalizedNodeStreamAttributeWriter) { - ((NormalizedNodeStreamAttributeWriter) writer).leafSetEntryNode(nodeAsLeafList.getNodeType(), - nodeAsLeafList.getValue(), nodeAsLeafList.getAttributes()); - } else { - writer.leafSetEntryNode(nodeAsLeafList.getNodeType(), nodeAsLeafList.getValue()); - } + writer.startLeafSetEntryNode(nodeAsLeafList.getIdentifier()); + writer.scalarValue(nodeAsLeafList.getValue()); + writer.endNode(); } return true; } else if (node instanceof LeafNode) { final LeafNode nodeAsLeaf = (LeafNode)node; - if (writer instanceof NormalizedNodeStreamAttributeWriter) { - ((NormalizedNodeStreamAttributeWriter) writer).leafNode( - nodeAsLeaf.getIdentifier(), nodeAsLeaf.getValue(), nodeAsLeaf.getAttributes()); - } else { - writer.leafNode(nodeAsLeaf.getIdentifier(), nodeAsLeaf.getValue()); - } + writer.startLeafNode(nodeAsLeaf.getIdentifier()); + writer.scalarValue(nodeAsLeaf.getValue()); + writer.endNode(); return true; } else if (node instanceof AnyXmlNode) { final AnyXmlNode anyXmlNode = (AnyXmlNode)node; - writer.anyxmlNode(anyXmlNode.getIdentifier(), anyXmlNode.getValue()); + writer.startAnyxmlNode(anyXmlNode.getIdentifier()); + writer.domSourceValue(anyXmlNode.getValue()); + writer.endNode(); return true; } @@ -241,18 +236,15 @@ public class ParameterAwareNormalizedNodeWriter implements RestconfNormalizedNod private void writeOnlyKeys(final Map keyValues) throws IllegalArgumentException, IOException { for (final Map.Entry entry : keyValues.entrySet()) { - writer.leafNode(new NodeIdentifier(entry.getKey()), entry.getValue()); + writer.startLeafNode(new NodeIdentifier(entry.getKey())); + writer.scalarValue(entry.getValue()); + writer.endNode(); } writer.endNode(); } protected boolean writeMapEntryNode(final MapEntryNode node) throws IOException { - if (writer instanceof NormalizedNodeStreamAttributeWriter) { - ((NormalizedNodeStreamAttributeWriter) writer) - .startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue()), node.getAttributes()); - } else { - writer.startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue())); - } + writer.startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue())); currentDepth++; writeMapEntryChildren(node); currentDepth--; @@ -264,12 +256,7 @@ public class ParameterAwareNormalizedNodeWriter implements RestconfNormalizedNod if (node instanceof ContainerNode) { final ContainerNode n = (ContainerNode) node; if (!n.getNodeType().withoutRevision().equals(ROOT_DATA_QNAME)) { - if (writer instanceof NormalizedNodeStreamAttributeWriter) { - ((NormalizedNodeStreamAttributeWriter) writer).startContainerNode( - n.getIdentifier(), childSizeHint(n.getValue()), n.getAttributes()); - } else { - writer.startContainerNode(n.getIdentifier(), childSizeHint(n.getValue())); - } + writer.startContainerNode(n.getIdentifier(), childSizeHint(n.getValue())); currentDepth++; processedAsCompositeNode = writeChildren(n.getValue(), false); currentDepth--; @@ -338,12 +325,7 @@ public class ParameterAwareNormalizedNodeWriter implements RestconfNormalizedNod @Override protected boolean writeMapEntryNode(final MapEntryNode node) throws IOException { final NormalizedNodeStreamWriter writer = getWriter(); - if (writer instanceof NormalizedNodeStreamAttributeWriter) { - ((NormalizedNodeStreamAttributeWriter) writer).startMapEntryNode( - node.getIdentifier(), childSizeHint(node.getValue()), node.getAttributes()); - } else { - writer.startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue())); - } + writer.startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue())); final Set qnames = node.getIdentifier().getKeyValues().keySet(); // Write out all the key children diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/XmlNormalizedNodeBodyReader.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/XmlNormalizedNodeBodyReader.java index debebb9d31..1fc91c4381 100644 --- a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/XmlNormalizedNodeBodyReader.java +++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/XmlNormalizedNodeBodyReader.java @@ -43,7 +43,7 @@ import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStre import org.opendaylight.yangtools.yang.data.codec.xml.XmlParserStream; import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter; import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult; -import org.opendaylight.yangtools.yang.data.impl.schema.SchemaUtils; +import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode; import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode; import org.opendaylight.yangtools.yang.model.api.AugmentationTarget; import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode; @@ -65,8 +65,8 @@ import org.xml.sax.SAXException; public class XmlNormalizedNodeBodyReader extends AbstractNormalizedNodeBodyReader { private static final Logger LOG = LoggerFactory.getLogger(XmlNormalizedNodeBodyReader.class); - public XmlNormalizedNodeBodyReader(SchemaContextHandler schemaContextHandler, - DOMMountPointServiceHandler mountPointServiceHandler) { + public XmlNormalizedNodeBodyReader(final SchemaContextHandler schemaContextHandler, + final DOMMountPointServiceHandler mountPointServiceHandler) { super(schemaContextHandler, mountPointServiceHandler); } @@ -115,7 +115,7 @@ public class XmlNormalizedNodeBodyReader extends AbstractNormalizedNodeBodyReade final Object child = foundSchemaNodes.pop(); if (child instanceof AugmentationSchemaNode) { final AugmentationSchemaNode augmentSchemaNode = (AugmentationSchemaNode) child; - iiToDataList.add(SchemaUtils.getNodeIdentifierForAugmentation(augmentSchemaNode)); + iiToDataList.add(DataSchemaContextNode.augmentationIdentifierFrom(augmentSchemaNode)); } else if (child instanceof DataSchemaNode) { schemaNode = (DataSchemaNode) child; iiToDataList.add(new YangInstanceIdentifier.NodeIdentifier(schemaNode.getQName())); diff --git a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/services/simple/impl/FakeRestconfModule.java b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/services/simple/impl/FakeRestconfModule.java index 8dcc91c214..d0e00e5139 100644 --- a/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/services/simple/impl/FakeRestconfModule.java +++ b/restconf/restconf-nb-rfc8040/src/main/java/org/opendaylight/restconf/nb/rfc8040/services/simple/impl/FakeRestconfModule.java @@ -34,7 +34,6 @@ import org.opendaylight.yangtools.yang.model.api.ModuleImport; import org.opendaylight.yangtools.yang.model.api.NotificationDefinition; import org.opendaylight.yangtools.yang.model.api.RpcDefinition; import org.opendaylight.yangtools.yang.model.api.TypeDefinition; -import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode; import org.opendaylight.yangtools.yang.model.api.UsesNode; /** @@ -186,11 +185,6 @@ final class FakeRestconfModule implements Module { throw new UnsupportedOperationException("Operation not implemented."); } - @Override - public List getUnknownSchemaNodes() { - throw new UnsupportedOperationException("Operation not implemented."); - } - @Override public Optional getSemanticVersion() { throw new UnsupportedOperationException("Operation not implemented."); diff --git a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/ParameterAwareNormalizedNodeWriterDepthTest.java b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/ParameterAwareNormalizedNodeWriterDepthTest.java index 51dbdef7af..a3e1f635cc 100644 --- a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/ParameterAwareNormalizedNodeWriterDepthTest.java +++ b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/ParameterAwareNormalizedNodeWriterDepthTest.java @@ -5,9 +5,14 @@ * 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.jersey.providers; +import static org.mockito.Mockito.inOrder; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoMoreInteractions; +import static org.mockito.Mockito.when; + import com.google.common.collect.Sets; import java.util.Collection; import java.util.Collections; @@ -15,10 +20,10 @@ import java.util.Optional; import org.junit.Before; import org.junit.Ignore; import org.junit.Test; +import org.junit.runner.RunWith; import org.mockito.InOrder; import org.mockito.Mock; -import org.mockito.Mockito; -import org.mockito.MockitoAnnotations; +import org.mockito.junit.MockitoJUnitRunner; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier; @@ -36,6 +41,7 @@ import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStre /** * Unit test for {@link ParameterAwareNormalizedNodeWriter} used with depth parameter. */ +@RunWith(MockitoJUnitRunner.StrictStubs.class) public class ParameterAwareNormalizedNodeWriterDepthTest { @Mock @@ -73,24 +79,21 @@ public class ParameterAwareNormalizedNodeWriterDepthTest { @Before public void setUp() { - MockitoAnnotations.initMocks(this); - // identifiers containerNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "container")); - Mockito.when(containerNodeData.getIdentifier()).thenReturn(containerNodeIdentifier); - Mockito.when(containerNodeData.getNodeType()).thenReturn(containerNodeIdentifier.getNodeType()); + when(containerNodeData.getIdentifier()).thenReturn(containerNodeIdentifier); + when(containerNodeData.getNodeType()).thenReturn(containerNodeIdentifier.getNodeType()); mapNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "list")); - Mockito.when(mapNodeData.getIdentifier()).thenReturn(mapNodeIdentifier); + when(mapNodeData.getIdentifier()).thenReturn(mapNodeIdentifier); final QName leafSetEntryNodeQName = QName.create("namespace", "leaf-set-entry"); leafSetEntryNodeValue = "leaf-set-value"; leafSetEntryNodeIdentifier = new NodeWithValue<>(leafSetEntryNodeQName, leafSetEntryNodeValue); - Mockito.when(leafSetEntryNodeData.getIdentifier()).thenReturn(leafSetEntryNodeIdentifier); - Mockito.when(leafSetEntryNodeData.getNodeType()).thenReturn(leafSetEntryNodeQName); + when(leafSetEntryNodeData.getIdentifier()).thenReturn(leafSetEntryNodeIdentifier); leafSetNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "leaf-set")); - Mockito.when(leafSetNodeData.getIdentifier()).thenReturn(leafSetNodeIdentifier); + when(leafSetNodeData.getIdentifier()).thenReturn(leafSetNodeIdentifier); final QName mapEntryNodeKey = QName.create("namespace", "key-field"); keyLeafNodeIdentifier = NodeIdentifier.create(mapEntryNodeKey); @@ -98,32 +101,32 @@ public class ParameterAwareNormalizedNodeWriterDepthTest { mapEntryNodeIdentifier = new YangInstanceIdentifier.NodeIdentifierWithPredicates( QName.create("namespace", "list-entry"), Collections.singletonMap(mapEntryNodeKey, keyLeafNodeValue)); - Mockito.when(mapEntryNodeData.getIdentifier()).thenReturn(mapEntryNodeIdentifier); - Mockito.when(mapEntryNodeData.getChild(keyLeafNodeIdentifier)).thenReturn(Optional.of(keyLeafNodeData)); + when(mapEntryNodeData.getIdentifier()).thenReturn(mapEntryNodeIdentifier); + when(mapEntryNodeData.getChild(keyLeafNodeIdentifier)).thenReturn(Optional.of(keyLeafNodeData)); - Mockito.when(keyLeafNodeData.getValue()).thenReturn(keyLeafNodeValue); - Mockito.when(keyLeafNodeData.getIdentifier()).thenReturn(keyLeafNodeIdentifier); + when(keyLeafNodeData.getValue()).thenReturn(keyLeafNodeValue); + when(keyLeafNodeData.getIdentifier()).thenReturn(keyLeafNodeIdentifier); anotherLeafNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "another-field")); anotherLeafNodeValue = "another-value"; - Mockito.when(anotherLeafNodeData.getValue()).thenReturn(anotherLeafNodeValue); - Mockito.when(anotherLeafNodeData.getIdentifier()).thenReturn(anotherLeafNodeIdentifier); + when(anotherLeafNodeData.getValue()).thenReturn(anotherLeafNodeValue); + when(anotherLeafNodeData.getIdentifier()).thenReturn(anotherLeafNodeIdentifier); // values - Mockito.when(leafSetEntryNodeData.getValue()).thenReturn(leafSetEntryNodeValue); + when(leafSetEntryNodeData.getValue()).thenReturn(leafSetEntryNodeValue); leafSetNodeValue = Collections.singletonList(leafSetEntryNodeData); - Mockito.when(leafSetNodeData.getValue()).thenReturn(leafSetNodeValue); + when(leafSetNodeData.getValue()).thenReturn(leafSetNodeValue); containerNodeValue = Collections.singleton(leafSetNodeData); - Mockito.when(containerNodeData.getValue()).thenReturn(containerNodeValue); + when(containerNodeData.getValue()).thenReturn(containerNodeValue); mapEntryNodeValue = Sets.newHashSet(keyLeafNodeData, anotherLeafNodeData); - Mockito.when(mapEntryNodeData.getValue()).thenReturn(mapEntryNodeValue); + when(mapEntryNodeData.getValue()).thenReturn(mapEntryNodeValue); mapNodeValue = Collections.singleton(mapEntryNodeData); - Mockito.when(mapNodeData.getValue()).thenReturn(mapNodeValue); + when(mapNodeData.getValue()).thenReturn(mapNodeValue); } /** @@ -137,10 +140,10 @@ public class ParameterAwareNormalizedNodeWriterDepthTest { parameterWriter.write(containerNodeData); - final InOrder inOrder = Mockito.inOrder(writer); - inOrder.verify(writer, Mockito.times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size()); - inOrder.verify(writer, Mockito.times(1)).endNode(); - Mockito.verifyNoMoreInteractions(writer); + final InOrder inOrder = inOrder(writer); + inOrder.verify(writer, times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size()); + inOrder.verify(writer, times(1)).endNode(); + verifyNoMoreInteractions(writer); } /** @@ -154,13 +157,13 @@ public class ParameterAwareNormalizedNodeWriterDepthTest { parameterWriter.write(containerNodeData); - final InOrder inOrder = Mockito.inOrder(writer); - inOrder.verify(writer, Mockito.times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size()); - inOrder.verify(writer, Mockito.times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size()); - inOrder.verify(writer, Mockito.times(1)).leafSetEntryNode( - leafSetEntryNodeIdentifier.getNodeType(), leafSetEntryNodeValue); - inOrder.verify(writer, Mockito.times(2)).endNode(); - Mockito.verifyNoMoreInteractions(writer); + final InOrder inOrder = inOrder(writer); + inOrder.verify(writer, times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size()); + inOrder.verify(writer, times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size()); + inOrder.verify(writer, times(1)).startLeafSetEntryNode(leafSetEntryNodeIdentifier); + inOrder.verify(writer, times(1)).scalarValue(leafSetEntryNodeValue); + inOrder.verify(writer, times(3)).endNode(); + verifyNoMoreInteractions(writer); } /** @@ -174,11 +177,11 @@ public class ParameterAwareNormalizedNodeWriterDepthTest { parameterWriter.write(mapNodeData); - final InOrder inOrder = Mockito.inOrder(writer); - inOrder.verify(writer, Mockito.times(1)).startMapNode(mapNodeIdentifier, mapNodeValue.size()); - inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size()); - inOrder.verify(writer, Mockito.times(2)).endNode(); - Mockito.verifyNoMoreInteractions(writer); + final InOrder inOrder = inOrder(writer); + inOrder.verify(writer, times(1)).startMapNode(mapNodeIdentifier, mapNodeValue.size()); + inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size()); + inOrder.verify(writer, times(2)).endNode(); + verifyNoMoreInteractions(writer); } /** @@ -196,14 +199,20 @@ public class ParameterAwareNormalizedNodeWriterDepthTest { parameterWriter.write(mapNodeData); - final InOrder inOrder = Mockito.inOrder(writer); - inOrder.verify(writer, Mockito.times(1)).startMapNode(mapNodeIdentifier, mapNodeValue.size()); - inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size()); - inOrder.verify(writer, Mockito.times(2)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue); + final InOrder inOrder = inOrder(writer); + inOrder.verify(writer, times(1)).startMapNode(mapNodeIdentifier, mapNodeValue.size()); + inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size()); + inOrder.verify(writer, times(2)).startLeafNode(keyLeafNodeIdentifier); + inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue); + inOrder.verify(writer, times(1)).endNode(); + inOrder.verify(writer, times(2)).startLeafNode(keyLeafNodeIdentifier); + inOrder.verify(writer, times(2)).scalarValue(keyLeafNodeValue); + inOrder.verify(writer, times(2)).endNode(); // FIXME this assertion is not working because leaves are not written in expected order - inOrder.verify(writer, Mockito.times(1)).leafNode(anotherLeafNodeIdentifier, anotherLeafNodeValue); - inOrder.verify(writer, Mockito.times(2)).endNode(); - Mockito.verifyNoMoreInteractions(writer); + inOrder.verify(writer, times(1)).startLeafNode(anotherLeafNodeIdentifier); + inOrder.verify(writer, times(1)).scalarValue(anotherLeafNodeValue); + inOrder.verify(writer, times(3)).endNode(); + verifyNoMoreInteractions(writer); } /** @@ -217,10 +226,10 @@ public class ParameterAwareNormalizedNodeWriterDepthTest { parameterWriter.write(leafSetNodeData); - final InOrder inOrder = Mockito.inOrder(writer); - inOrder.verify(writer, Mockito.times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size()); - inOrder.verify(writer, Mockito.times(1)).endNode(); - Mockito.verifyNoMoreInteractions(writer); + final InOrder inOrder = inOrder(writer); + inOrder.verify(writer, times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size()); + inOrder.verify(writer, times(1)).endNode(); + verifyNoMoreInteractions(writer); } /** @@ -234,12 +243,12 @@ public class ParameterAwareNormalizedNodeWriterDepthTest { parameterWriter.write(leafSetNodeData); - final InOrder inOrder = Mockito.inOrder(writer); - inOrder.verify(writer, Mockito.times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size()); - inOrder.verify(writer, Mockito.times(1)).leafSetEntryNode( - leafSetEntryNodeIdentifier.getNodeType(), leafSetEntryNodeValue); - inOrder.verify(writer, Mockito.times(1)).endNode(); - Mockito.verifyNoMoreInteractions(writer); + final InOrder inOrder = inOrder(writer); + inOrder.verify(writer, times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size()); + inOrder.verify(writer, times(1)).startLeafSetEntryNode(leafSetEntryNodeIdentifier); + inOrder.verify(writer, times(1)).scalarValue(leafSetEntryNodeValue); + inOrder.verify(writer, times(2)).endNode(); + verifyNoMoreInteractions(writer); } /** @@ -253,10 +262,11 @@ public class ParameterAwareNormalizedNodeWriterDepthTest { parameterWriter.write(leafSetEntryNodeData); - final InOrder inOrder = Mockito.inOrder(writer); - inOrder.verify(writer, Mockito.times(1)).leafSetEntryNode( - leafSetEntryNodeIdentifier.getNodeType(), leafSetEntryNodeValue); - Mockito.verifyNoMoreInteractions(writer); + final InOrder inOrder = inOrder(writer); + inOrder.verify(writer, times(1)).startLeafSetEntryNode(leafSetEntryNodeIdentifier); + inOrder.verify(writer, times(1)).scalarValue(leafSetEntryNodeValue); + inOrder.verify(writer, times(1)).endNode(); + verifyNoMoreInteractions(writer); } /** @@ -270,12 +280,13 @@ public class ParameterAwareNormalizedNodeWriterDepthTest { parameterWriter.write(mapEntryNodeData); - final InOrder inOrder = Mockito.inOrder(writer); - inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size()); + final InOrder inOrder = inOrder(writer); + inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size()); // write only the key - inOrder.verify(writer, Mockito.times(1)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue); - inOrder.verify(writer, Mockito.times(1)).endNode(); - Mockito.verifyNoMoreInteractions(writer); + inOrder.verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier); + inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue); + inOrder.verify(writer, times(2)).endNode(); + verifyNoMoreInteractions(writer); } /** @@ -290,11 +301,13 @@ public class ParameterAwareNormalizedNodeWriterDepthTest { parameterWriter.write(mapEntryNodeData); // unordered - Mockito.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size()); - Mockito.verify(writer, Mockito.times(1)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue); - Mockito.verify(writer, Mockito.times(1)).leafNode(anotherLeafNodeIdentifier, anotherLeafNodeValue); - Mockito.verify(writer, Mockito.times(1)).endNode(); - Mockito.verifyNoMoreInteractions(writer); + verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size()); + verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier); + verify(writer, times(1)).scalarValue(keyLeafNodeValue); + verify(writer, times(1)).startLeafNode(anotherLeafNodeIdentifier); + verify(writer, times(1)).scalarValue(anotherLeafNodeValue); + verify(writer, times(3)).endNode(); + verifyNoMoreInteractions(writer); } /** @@ -308,10 +321,10 @@ public class ParameterAwareNormalizedNodeWriterDepthTest { parameterWriter.write(mapEntryNodeData); - final InOrder inOrder = Mockito.inOrder(writer); - inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size()); - inOrder.verify(writer, Mockito.times(1)).endNode(); - Mockito.verifyNoMoreInteractions(writer); + final InOrder inOrder = inOrder(writer); + inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size()); + inOrder.verify(writer, times(1)).endNode(); + verifyNoMoreInteractions(writer); } /** @@ -329,12 +342,18 @@ public class ParameterAwareNormalizedNodeWriterDepthTest { parameterWriter.write(mapEntryNodeData); - final InOrder inOrder = Mockito.inOrder(writer); - inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size()); - inOrder.verify(writer, Mockito.times(2)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue); + final InOrder inOrder = inOrder(writer); + inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size()); + inOrder.verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier); + inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue); + inOrder.verify(writer, times(1)).endNode(); + inOrder.verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier); + inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue); + inOrder.verify(writer, times(1)).endNode(); // FIXME this assertion is not working because leaves are not written in expected order - inOrder.verify(writer, Mockito.times(1)).leafNode(anotherLeafNodeIdentifier, anotherLeafNodeValue); - inOrder.verify(writer, Mockito.times(1)).endNode(); - Mockito.verifyNoMoreInteractions(writer); + inOrder.verify(writer, times(1)).startLeafNode(anotherLeafNodeIdentifier); + inOrder.verify(writer, times(1)).scalarValue(anotherLeafNodeValue); + inOrder.verify(writer, times(2)).endNode(); + verifyNoMoreInteractions(writer); } } \ No newline at end of file diff --git a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/ParameterAwareNormalizedNodeWriterFieldsTest.java b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/ParameterAwareNormalizedNodeWriterFieldsTest.java index e3c4fa6863..883218ee1c 100644 --- a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/ParameterAwareNormalizedNodeWriterFieldsTest.java +++ b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/ParameterAwareNormalizedNodeWriterFieldsTest.java @@ -160,9 +160,9 @@ public class ParameterAwareNormalizedNodeWriterFieldsTest { final InOrder inOrder = Mockito.inOrder(writer); inOrder.verify(writer, Mockito.times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size()); inOrder.verify(writer, Mockito.times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size()); - inOrder.verify(writer, Mockito.times(1)).leafSetEntryNode( - leafSetEntryNodeIdentifier.getNodeType(), leafSetEntryNodeValue); - inOrder.verify(writer, Mockito.times(2)).endNode(); + inOrder.verify(writer, Mockito.times(1)).startLeafSetEntryNode(leafSetEntryNodeIdentifier); + inOrder.verify(writer, Mockito.times(1)).scalarValue(leafSetEntryNodeValue); + inOrder.verify(writer, Mockito.times(3)).endNode(); Mockito.verifyNoMoreInteractions(writer); } @@ -204,8 +204,9 @@ public class ParameterAwareNormalizedNodeWriterFieldsTest { final InOrder inOrder = Mockito.inOrder(writer); inOrder.verify(writer, Mockito.times(1)).startMapNode(mapNodeIdentifier, mapNodeValue.size()); inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size()); - inOrder.verify(writer, Mockito.times(1)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue); - inOrder.verify(writer, Mockito.times(2)).endNode(); + inOrder.verify(writer, Mockito.times(1)).startLeafNode(keyLeafNodeIdentifier); + inOrder.verify(writer, Mockito.times(1)).scalarValue(keyLeafNodeValue); + inOrder.verify(writer, Mockito.times(3)).endNode(); Mockito.verifyNoMoreInteractions(writer); } } \ No newline at end of file diff --git a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/ParameterAwareNormalizedNodeWriterParametersTest.java b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/ParameterAwareNormalizedNodeWriterParametersTest.java index ffb10e3dda..3415198f97 100644 --- a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/ParameterAwareNormalizedNodeWriterParametersTest.java +++ b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/ParameterAwareNormalizedNodeWriterParametersTest.java @@ -114,9 +114,9 @@ public class ParameterAwareNormalizedNodeWriterParametersTest { final InOrder inOrder = Mockito.inOrder(writer); inOrder.verify(writer, Mockito.times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size()); inOrder.verify(writer, Mockito.times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size()); - inOrder.verify(writer, Mockito.times(1)).leafSetEntryNode( - leafSetEntryNodeIdentifier.getNodeType(), leafSetEntryNodeValue); - inOrder.verify(writer, Mockito.times(2)).endNode(); + inOrder.verify(writer, Mockito.times(1)).startLeafSetEntryNode(leafSetEntryNodeIdentifier); + inOrder.verify(writer, Mockito.times(1)).scalarValue(leafSetEntryNodeValue); + inOrder.verify(writer, Mockito.times(3)).endNode(); Mockito.verifyNoMoreInteractions(writer); } @@ -133,9 +133,9 @@ public class ParameterAwareNormalizedNodeWriterParametersTest { final InOrder inOrder = Mockito.inOrder(writer); inOrder.verify(writer, Mockito.times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size()); - inOrder.verify(writer, Mockito.times(1)).leafSetEntryNode( - leafSetEntryNodeIdentifier.getNodeType(), leafSetEntryNodeValue); - inOrder.verify(writer, Mockito.times(1)).endNode(); + inOrder.verify(writer, Mockito.times(1)).startLeafSetEntryNode(leafSetEntryNodeIdentifier); + inOrder.verify(writer, Mockito.times(1)).scalarValue(leafSetEntryNodeValue); + inOrder.verify(writer, Mockito.times(2)).endNode(); Mockito.verifyNoMoreInteractions(writer); } } \ No newline at end of file diff --git a/restconf/sal-rest-docgen/src/main/java/org/opendaylight/netconf/sal/rest/doc/impl/ModelGenerator.java b/restconf/sal-rest-docgen/src/main/java/org/opendaylight/netconf/sal/rest/doc/impl/ModelGenerator.java index 1857cc41e2..aaeb0ce664 100644 --- a/restconf/sal-rest-docgen/src/main/java/org/opendaylight/netconf/sal/rest/doc/impl/ModelGenerator.java +++ b/restconf/sal-rest-docgen/src/main/java/org/opendaylight/netconf/sal/rest/doc/impl/ModelGenerator.java @@ -37,7 +37,7 @@ import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode; import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; import org.opendaylight.yangtools.yang.model.api.MandatoryAware; import org.opendaylight.yangtools.yang.model.api.Module; -import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath; +import org.opendaylight.yangtools.yang.model.api.PathExpression; import org.opendaylight.yangtools.yang.model.api.RpcDefinition; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.model.api.SchemaNode; @@ -58,7 +58,7 @@ import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint; import org.opendaylight.yangtools.yang.model.api.type.RangeRestrictedTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition; -import org.opendaylight.yangtools.yang.model.util.RevisionAwareXPathImpl; +import org.opendaylight.yangtools.yang.model.util.PathExpressionImpl; import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -515,11 +515,11 @@ public class ModelGenerator { private String processLeafRef(final DataSchemaNode node, final ObjectNode property, final SchemaContext schemaContext, final TypeDefinition leafTypeDef) { - RevisionAwareXPath xpath = ((LeafrefTypeDefinition) leafTypeDef).getPathStatement(); + PathExpression xpath = ((LeafrefTypeDefinition) leafTypeDef).getPathStatement(); final SchemaNode schemaNode; - final String xPathString = STRIP_PATTERN.matcher(xpath.toString()).replaceAll(""); - xpath = new RevisionAwareXPathImpl(xPathString, xpath.isAbsolute()); + final String xPathString = STRIP_PATTERN.matcher(xpath.getOriginalString()).replaceAll(""); + xpath = new PathExpressionImpl(xPathString, xpath.isAbsolute()); final Module module; if (xpath.isAbsolute()) { -- 2.36.6