Code Review / yangtools.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
Add XMLNamespace
[yangtools.git] / yang / yang-model-util / src / test / java / org / opendaylight / yangtools / yang / model / util / SchemaContextProxyTest.java
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 497508074bd309c796ba24f3562a71636e1d2379..d17567d14337992b1e444cdc4cce5c1a064211dd 100644 (file)
--- 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<Module> 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<DataSchemaNode> childNodes = Collections.singleton(mockedContainer);
         doReturn(childNodes).when(moduleConfig).getChildNodes();
 
-        final Set<DataSchemaNode> dataDefinitions = filteringSchemaContextProxy.getDataDefinitions();
+        final Collection<? extends DataSchemaNode> dataDefinitions =
+                filteringSchemaContextProxy.getDataDefinitions();
         assertTrue(dataDefinitions.contains(mockedContainer));
     }
 
@@ -420,7 +428,7 @@ public class SchemaContextProxyTest {
         final Set<NotificationDefinition> notifications = Collections.singleton(mockedNotification);
         doReturn(notifications).when(moduleConfig).getNotifications();
 
-        final Set<NotificationDefinition> schemaContextProxyNotifications =
+        final Collection<? extends NotificationDefinition> schemaContextProxyNotifications =
             filteringSchemaContextProxy.getNotifications();
         assertTrue(schemaContextProxyNotifications.contains(mockedNotification));
     }
@@ -436,7 +444,7 @@ public class SchemaContextProxyTest {
         final Set<RpcDefinition> rpcs = Collections.singleton(mockedRpc);
         doReturn(rpcs).when(moduleConfig).getRpcs();
 
-        final Set<RpcDefinition> operations = filteringSchemaContextProxy.getOperations();
+        final Collection<? extends RpcDefinition> operations = filteringSchemaContextProxy.getOperations();
         assertTrue(operations.contains(mockedRpc));
     }
 
@@ -451,7 +459,8 @@ public class SchemaContextProxyTest {
         final List<ExtensionDefinition> extensions = Collections.singletonList(mockedExtension);
         doReturn(extensions).when(moduleConfig).getExtensionSchemaNodes();
 
-        final Set<ExtensionDefinition> schemaContextProxyExtensions = filteringSchemaContextProxy.getExtensions();
+        final Collection<? extends ExtensionDefinition> schemaContextProxyExtensions =
+                filteringSchemaContextProxy.getExtensions();
         assertTrue(schemaContextProxyExtensions.contains(mockedExtension));
     }
 
@@ -466,7 +475,7 @@ public class SchemaContextProxyTest {
         final List<UnknownSchemaNode> unknownSchemaNodes = Collections.singletonList(mockedUnknownSchemaNode);
         doReturn(unknownSchemaNodes).when(moduleConfig).getUnknownSchemaNodes();
 
-        final List<UnknownSchemaNode> schemaContextProxyUnknownSchemaNodes =
+        final Collection<? extends UnknownSchemaNode> schemaContextProxyUnknownSchemaNodes =
                 filteringSchemaContextProxy.getUnknownSchemaNodes();
         assertTrue(schemaContextProxyUnknownSchemaNodes.contains(mockedUnknownSchemaNode));
     }
@@ -482,7 +491,7 @@ public class SchemaContextProxyTest {
         final Set<TypeDefinition<?>> typeDefinitions = Collections.singleton(mockedTypeDefinition);
         doReturn(typeDefinitions).when(moduleConfig).getTypeDefinitions();
 
-        final Set<TypeDefinition<?>> schemaContextProxyTypeDefinitions = filteringSchemaContextProxy
+        final Collection<? extends TypeDefinition<?>> schemaContextProxyTypeDefinitions = filteringSchemaContextProxy
             .getTypeDefinitions();
         assertTrue(schemaContextProxyTypeDefinitions.contains(mockedTypeDefinition));
     }
@@ -498,7 +507,8 @@ public class SchemaContextProxyTest {
         final Set<DataSchemaNode> childNodes = Collections.singleton(mockedContainer);
         doReturn(childNodes).when(moduleConfig).getChildNodes();
 
-        final Set<DataSchemaNode> schemaContextProxyChildNodes = filteringSchemaContextProxy.getChildNodes();
+        final Collection<? extends DataSchemaNode> schemaContextProxyChildNodes =
+                filteringSchemaContextProxy.getChildNodes();
         assertTrue(schemaContextProxyChildNodes.contains(mockedContainer));
     }
 
@@ -513,7 +523,8 @@ public class SchemaContextProxyTest {
         final Set<GroupingDefinition> groupings = Collections.singleton(mockedGrouping);
         doReturn(groupings).when(moduleConfig).getGroupings();
 
-        final Set<GroupingDefinition> schemaContextProxyGroupings = filteringSchemaContextProxy.getGroupings();
+        final Collection<? extends GroupingDefinition> 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<Module> mod = filteringSchemaContextProxy.findModules(module.getNamespace());
+                Collection<? extends Module> 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<Module> submodulesSet = new HashSet<>();
+    private static void mockSubmodules(final Module mainModule, final Submodule... submodules) {
+        Set<Submodule> 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<ModuleImport> 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<String> getDescription() {
+                    return module.getDescription();
+                }
+
+                @Override
+                public Optional<String> 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;
     }
 }
OpenDaylight YANG Tools