X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;ds=sidebyside;f=yang%2Fyang-model-util%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fmodel%2Futil%2FSchemaContextProxyTest.java;h=d17567d14337992b1e444cdc4cce5c1a064211dd;hb=c4517068c0183a892703b26baf098c97bfb2a854;hp=497508074bd309c796ba24f3562a71636e1d2379;hpb=b212baa59f859732bd3a799425bb420035fe6154;p=yangtools.git diff --git a/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/SchemaContextProxyTest.java b/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/SchemaContextProxyTest.java index 497508074b..d17567d143 100644 --- a/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/SchemaContextProxyTest.java +++ b/yang/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/SchemaContextProxyTest.java @@ -9,13 +9,14 @@ package org.opendaylight.yangtools.yang.model.util; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; -import static org.mockito.Matchers.any; +import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import com.google.common.collect.ImmutableSet; import java.net.URI; import java.util.Arrays; +import java.util.Collection; import java.util.Collections; import java.util.HashSet; import java.util.List; @@ -26,24 +27,28 @@ import org.opendaylight.yangtools.concepts.SemVer; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.common.QNameModule; import org.opendaylight.yangtools.yang.common.Revision; +import org.opendaylight.yangtools.yang.common.XMLNamespace; import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode; import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition; import org.opendaylight.yangtools.yang.model.api.GroupingDefinition; import org.opendaylight.yangtools.yang.model.api.Module; import org.opendaylight.yangtools.yang.model.api.ModuleImport; +import org.opendaylight.yangtools.yang.model.api.ModuleLike; import org.opendaylight.yangtools.yang.model.api.NotificationDefinition; import org.opendaylight.yangtools.yang.model.api.RpcDefinition; import org.opendaylight.yangtools.yang.model.api.SchemaContext; +import org.opendaylight.yangtools.yang.model.api.Submodule; import org.opendaylight.yangtools.yang.model.api.TypeDefinition; import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode; +import org.opendaylight.yangtools.yang.model.api.stmt.ImportEffectiveStatement; import org.opendaylight.yangtools.yang.model.util.FilteringSchemaContextProxy.ModuleId; public class SchemaContextProxyTest { private static final URI NAMESPACE = URI.create("urn:opendaylight:params:xml:ns:yang:controller:config"); - private static final Revision REVISION = Revision.valueOf("2015-01-01"); - private static final Revision REVISION2 = Revision.valueOf("2015-01-15"); + private static final Revision REVISION = Revision.of("2015-01-01"); + private static final Revision REVISION2 = Revision.of("2015-01-15"); private static final String CONFIG_NAME = "config"; private static final String ROOT_NAME = "root"; @@ -53,9 +58,11 @@ public class SchemaContextProxyTest { private static final String MODULE41_NAME = "module41"; private static final String MODULE5_NAME = "module5"; - private static SchemaContext mockSchema(final Module... module) { + private static SchemaContext mockSchema(final Module... modules) { + final List sortedModules = Arrays.asList(modules); + sortedModules.sort(AbstractSchemaContext.NAME_REVISION_COMPARATOR); SchemaContext mock = mock(SchemaContext.class); - doReturn(ImmutableSet.copyOf(module)).when(mock).getModules(); + doReturn(ImmutableSet.copyOf(sortedModules)).when(mock).getModules(); return mock; } @@ -134,10 +141,10 @@ public class SchemaContextProxyTest { */ @Test public void testBasicNullRevision() throws Exception { - final Module moduleConfig = mockModule(CONFIG_NAME, Revision.valueOf("2013-04-05")); - final Module module2 = mockModule(MODULE2_NAME, Revision.valueOf("2014-06-17")); + final Module moduleConfig = mockModule(CONFIG_NAME, Revision.of("2013-04-05")); + final Module module2 = mockModule(MODULE2_NAME, Revision.of("2014-06-17")); final Module module20 = mockModule(MODULE2_NAME, null); - final Module module3 = mockModule(MODULE3_NAME, Revision.valueOf("2014-06-12")); + final Module module3 = mockModule(MODULE3_NAME, Revision.of("2014-06-12")); final Module module30 = mockModule(MODULE3_NAME, null); mockModuleImport(module20, moduleConfig); @@ -283,7 +290,7 @@ public class SchemaContextProxyTest { Module moduleConfig = mockModule(CONFIG_NAME); Module module2 = mockModule(MODULE2_NAME); Module module3 = mockModule(MODULE3_NAME); - Module module4 = mockModule(MODULE3_NAME, Revision.valueOf("2015-10-10")); + Module module4 = mockModule(MODULE3_NAME, Revision.of("2015-10-10")); mockModuleImport(module2, moduleConfig); mockModuleImport(module3, module2, moduleConfig); @@ -332,7 +339,7 @@ public class SchemaContextProxyTest { Module module2 = mockModule(MODULE2_NAME); Module module3 = mockModule(MODULE3_NAME); Module module4 = mockModule(MODULE4_NAME); - Module module41 = mockModule(MODULE41_NAME); + Submodule module41 = mockSubmodule(MODULE41_NAME); mockSubmodules(module4, module41); mockModuleImport(module2, moduleConfig, module3); @@ -405,7 +412,8 @@ public class SchemaContextProxyTest { final Set childNodes = Collections.singleton(mockedContainer); doReturn(childNodes).when(moduleConfig).getChildNodes(); - final Set dataDefinitions = filteringSchemaContextProxy.getDataDefinitions(); + final Collection dataDefinitions = + filteringSchemaContextProxy.getDataDefinitions(); assertTrue(dataDefinitions.contains(mockedContainer)); } @@ -420,7 +428,7 @@ public class SchemaContextProxyTest { final Set notifications = Collections.singleton(mockedNotification); doReturn(notifications).when(moduleConfig).getNotifications(); - final Set schemaContextProxyNotifications = + final Collection schemaContextProxyNotifications = filteringSchemaContextProxy.getNotifications(); assertTrue(schemaContextProxyNotifications.contains(mockedNotification)); } @@ -436,7 +444,7 @@ public class SchemaContextProxyTest { final Set rpcs = Collections.singleton(mockedRpc); doReturn(rpcs).when(moduleConfig).getRpcs(); - final Set operations = filteringSchemaContextProxy.getOperations(); + final Collection operations = filteringSchemaContextProxy.getOperations(); assertTrue(operations.contains(mockedRpc)); } @@ -451,7 +459,8 @@ public class SchemaContextProxyTest { final List extensions = Collections.singletonList(mockedExtension); doReturn(extensions).when(moduleConfig).getExtensionSchemaNodes(); - final Set schemaContextProxyExtensions = filteringSchemaContextProxy.getExtensions(); + final Collection schemaContextProxyExtensions = + filteringSchemaContextProxy.getExtensions(); assertTrue(schemaContextProxyExtensions.contains(mockedExtension)); } @@ -466,7 +475,7 @@ public class SchemaContextProxyTest { final List unknownSchemaNodes = Collections.singletonList(mockedUnknownSchemaNode); doReturn(unknownSchemaNodes).when(moduleConfig).getUnknownSchemaNodes(); - final List schemaContextProxyUnknownSchemaNodes = + final Collection schemaContextProxyUnknownSchemaNodes = filteringSchemaContextProxy.getUnknownSchemaNodes(); assertTrue(schemaContextProxyUnknownSchemaNodes.contains(mockedUnknownSchemaNode)); } @@ -482,7 +491,7 @@ public class SchemaContextProxyTest { final Set> typeDefinitions = Collections.singleton(mockedTypeDefinition); doReturn(typeDefinitions).when(moduleConfig).getTypeDefinitions(); - final Set> schemaContextProxyTypeDefinitions = filteringSchemaContextProxy + final Collection> schemaContextProxyTypeDefinitions = filteringSchemaContextProxy .getTypeDefinitions(); assertTrue(schemaContextProxyTypeDefinitions.contains(mockedTypeDefinition)); } @@ -498,7 +507,8 @@ public class SchemaContextProxyTest { final Set childNodes = Collections.singleton(mockedContainer); doReturn(childNodes).when(moduleConfig).getChildNodes(); - final Set schemaContextProxyChildNodes = filteringSchemaContextProxy.getChildNodes(); + final Collection schemaContextProxyChildNodes = + filteringSchemaContextProxy.getChildNodes(); assertTrue(schemaContextProxyChildNodes.contains(mockedContainer)); } @@ -513,7 +523,8 @@ public class SchemaContextProxyTest { final Set groupings = Collections.singleton(mockedGrouping); doReturn(groupings).when(moduleConfig).getGroupings(); - final Set schemaContextProxyGroupings = filteringSchemaContextProxy.getGroupings(); + final Collection schemaContextProxyGroupings = + filteringSchemaContextProxy.getGroupings(); assertTrue(schemaContextProxyGroupings.contains(mockedGrouping)); } @@ -526,7 +537,7 @@ public class SchemaContextProxyTest { final QName qname = QName.create("config-namespace", "2016-08-11", "cont"); final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class); - doReturn(mockedContainer).when(moduleConfig).getDataChildByName(any(QName.class)); + doReturn(mockedContainer).when(moduleConfig).dataChildByName(any(QName.class)); final DataSchemaNode dataSchemaNode = filteringSchemaContextProxy.getDataChildByName(qname); assertTrue(dataSchemaNode instanceof ContainerSchemaNode); @@ -546,7 +557,7 @@ public class SchemaContextProxyTest { assertEquals(module, filteringSchemaContextProxy.findModule(module.getName(), module.getRevision()) .get()); - Set mod = filteringSchemaContextProxy.findModules(module.getNamespace()); + Collection mod = filteringSchemaContextProxy.findModules(module.getNamespace()); assertTrue(mod.contains(module)); assertEquals(module, filteringSchemaContextProxy.findModule(module.getNamespace(), module.getRevision().orElse(null)).get()); @@ -576,14 +587,14 @@ public class SchemaContextProxyTest { return moduleIds; } - private static void mockSubmodules(final Module mainModule, final Module... submodules) { - Set submodulesSet = new HashSet<>(); + private static void mockSubmodules(final Module mainModule, final Submodule... submodules) { + Set submodulesSet = new HashSet<>(); submodulesSet.addAll(Arrays.asList(submodules)); doReturn(submodulesSet).when(mainModule).getSubmodules(); } - private static void mockModuleImport(final Module importer, final Module... imports) { + private static void mockModuleImport(final ModuleLike importer, final Module... imports) { Set mockedImports = new HashSet<>(); for (final Module module : imports) { mockedImports.add(new ModuleImport() { @@ -607,10 +618,25 @@ public class SchemaContextProxyTest { return module.getSemanticVersion(); } + @Override + public Optional getDescription() { + return module.getDescription(); + } + + @Override + public Optional getReference() { + return module.getReference(); + } + @Override public String toString() { return String.format("Module: %s, revision:%s", module.getName(), module.getRevision()); } + + @Override + public ImportEffectiveStatement asEffectiveStatement() { + throw new UnsupportedOperationException(); + } }); } doReturn(mockedImports).when(importer).getImports(); @@ -630,17 +656,25 @@ public class SchemaContextProxyTest { //mock module with default revision private static Module mockModule(final String name) { - Module mockedModule = mock(Module.class); + mockModuleLike(mockedModule, name); + return mockedModule; + } + + private static Submodule mockSubmodule(final String name) { + Submodule mockedModule = mock(Submodule.class); + mockModuleLike(mockedModule, name); + return mockedModule; + } + + private static void mockModuleLike(final ModuleLike mockedModule, final String name) { doReturn(name).when(mockedModule).getName(); doReturn(Optional.of(REVISION)).when(mockedModule).getRevision(); - final URI newNamespace = URI.create(NAMESPACE.toString() + ":" + name); + final XMLNamespace newNamespace = XMLNamespace.of(NAMESPACE.toString() + ":" + name); doReturn(newNamespace).when(mockedModule).getNamespace(); doReturn(QNameModule.create(newNamespace, REVISION)).when(mockedModule).getQNameModule(); doReturn(new HashSet<>()).when(mockedModule).getSubmodules(); doReturn(mockedModule.getQNameModule().toString()).when(mockedModule).toString(); mockModuleImport(mockedModule); - - return mockedModule; } }