/*
- * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ * Copyright (c) 2018 Pantheon Technologies, s.r.o. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
*/
package org.opendaylight.yangtools.yang.parser.util;
-import static org.hamcrest.core.AnyOf.anyOf;
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
-import static org.junit.matchers.JUnitMatchers.containsString;
+import static com.google.common.collect.ImmutableList.of;
+import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-import com.google.common.collect.Sets;
-import java.text.DateFormat;
-import java.text.SimpleDateFormat;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Date;
-import java.util.HashMap;
+import com.google.common.collect.ImmutableSet;
+import java.net.URI;
import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-import org.hamcrest.Matcher;
+import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
-import org.opendaylight.yangtools.yang.parser.util.ModuleDependencySort.ModuleNodeImpl;
-import org.opendaylight.yangtools.yang.parser.util.TopologicalSort.Edge;
+@RunWith(MockitoJUnitRunner.class)
public class ModuleDependencySortTest {
- private final DateFormat SIMPLE_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd");
- private final ModuleBuilder a = mockModuleBuilder("a", null);
- private final ModuleBuilder b = mockModuleBuilder("b", null);
- private final ModuleBuilder c = mockModuleBuilder("c", null);
- private final ModuleBuilder d = mockModuleBuilder("d", null);
-
- @Test
- public void testValid() throws Exception {
-
- mockDependency(a, b);
- mockDependency(b, c);
- mockDependency(b, d);
-
- ModuleBuilder[] builders = new ModuleBuilder[] { d, b, c, a };
-
- List<ModuleBuilder> l = ModuleDependencySort.sort(builders);
-
- assertDependencyGraph(ModuleDependencySort.createModuleGraph(ModuleOrModuleBuilder.fromAll(
- Collections.<Module>emptySet(), Arrays.asList(builders))));
-
- @SuppressWarnings("unchecked")
- Matcher<String> cOrD = anyOf(is(c.getName()), is(d.getName()));
-
- assertThat(l.get(0).getName(), cOrD);
- assertThat(l.get(1).getName(), cOrD);
- assertThat(l.get(2).getName(), is(b.getName()));
- assertThat(l.get(3).getName(), is(a.getName()));
- }
-
- @Test
- public void testValidModule() throws Exception {
-
- Date rev = new Date();
- Module a = mockModule("a", rev);
- Module b = mockModule("b", rev);
- Module c = mockModule("c", rev);
-
- mockDependency(a, b);
- mockDependency(b, c);
- mockDependency(a, c);
-
- Module[] builders = new Module[] { a, b, c };
-
- List<Module> l = ModuleDependencySort.sort(builders);
-
- assertThat(l.get(0).getName(), is(c.getName()));
- assertThat(l.get(1).getName(), is(b.getName()));
- assertThat(l.get(2).getName(), is(a.getName()));
- }
-
- @Test(expected = YangValidationException.class)
- public void testModuleTwice() throws Exception {
- ModuleBuilder a2 = mockModuleBuilder("a", null);
-
- ModuleBuilder[] builders = new ModuleBuilder[] { a, a2 };
- try {
- ModuleDependencySort.sort(builders);
- } catch (YangValidationException e) {
- assertThat(e.getMessage(), containsString("Module:a with revision:default declared twice"));
- throw e;
- }
- }
-
- @Test(expected = YangValidationException.class)
- public void testImportNotExistingModule() throws Exception {
- mockDependency(a, b);
-
- ModuleBuilder[] builders = new ModuleBuilder[] { a };
- try {
- ModuleDependencySort.sort(builders);
- } catch (YangValidationException e) {
- assertThat(e.getMessage(), containsString("Not existing module imported:b:default by:a:default"));
- throw e;
- }
+ private static final QNameModule FOO_MODULE = QNameModule.create(URI.create("foo"), null);
+ private static final QNameModule BAR_MODULE = QNameModule.create(URI.create("bar"), null);
+
+ @Mock
+ private Module fooNoRev;
+
+ @Mock
+ private ModuleImport fooNoRevImport;
+
+ @Mock
+ private Module bar;
+
+ @Mock
+ private Module barSubmodule;
+
+ @Before
+ public void before() {
+ doReturn("foo").when(fooNoRev).getName();
+ doReturn(FOO_MODULE).when(fooNoRev).getQNameModule();
+ doReturn(FOO_MODULE.getNamespace()).when(fooNoRev).getNamespace();
+ doReturn(FOO_MODULE.getRevision()).when(fooNoRev).getRevision();
+ doReturn(YangVersion.VERSION_1.toString()).when(fooNoRev).getYangVersion();
+ doReturn(ImmutableSet.of()).when(fooNoRev).getImports();
+ doReturn(ImmutableSet.of()).when(fooNoRev).getSubmodules();
+
+ doReturn("foo").when(fooNoRevImport).getModuleName();
+ doReturn(null).when(fooNoRevImport).getRevision();
+
+ doReturn("bar").when(bar).getName();
+ doReturn(BAR_MODULE).when(bar).getQNameModule();
+ doReturn(BAR_MODULE.getNamespace()).when(bar).getNamespace();
+ doReturn(BAR_MODULE.getRevision()).when(bar).getRevision();
+ doReturn(YangVersion.VERSION_1.toString()).when(bar).getYangVersion();
+ doReturn(ImmutableSet.of()).when(bar).getImports();
+ doReturn(ImmutableSet.of(barSubmodule)).when(bar).getSubmodules();
+
+ doReturn("bar-submodule").when(barSubmodule).getName();
+ doReturn(BAR_MODULE).when(barSubmodule).getQNameModule();
+ doReturn(BAR_MODULE.getNamespace()).when(barSubmodule).getNamespace();
+ doReturn(BAR_MODULE.getRevision()).when(barSubmodule).getRevision();
+ doReturn(ImmutableSet.of(fooNoRevImport)).when(barSubmodule).getImports();
+ doReturn(ImmutableSet.of()).when(barSubmodule).getSubmodules();
}
@Test
- public void testImportTwice() throws Exception {
- mockDependency(a, b);
- mockDependency(c, b);
-
- ModuleBuilder[] builders = new ModuleBuilder[] { a, b, c };
- ModuleDependencySort.sort(builders);
+ public void testSimpleModules() {
+ assertSortedTo(of(fooNoRev), fooNoRev);
}
@Test
- public void testModuleTwiceWithDifferentRevs() throws Exception {
- ModuleBuilder a2 = mockModuleBuilder("a", new Date());
-
- ModuleBuilder[] builders = new ModuleBuilder[] { a, a2 };
- ModuleDependencySort.sort(builders);
- }
-
- @Test(expected = YangValidationException.class)
- public void testModuleTwice2() throws Exception {
- Date rev = new Date();
- ModuleBuilder a2 = mockModuleBuilder("a", rev);
- ModuleBuilder a3 = mockModuleBuilder("a", rev);
-
- ModuleBuilder[] builders = new ModuleBuilder[] { a, a2, a3 };
- try {
- ModuleDependencySort.sort(builders);
- } catch (YangValidationException e) {
- assertThat(e.getMessage(), containsString("Module:a with revision:" + SIMPLE_DATE_FORMAT.format(rev)
- + " declared twice"));
- throw e;
- }
- }
-
- private void assertDependencyGraph(final Map<String, Map<Date, ModuleNodeImpl>> moduleGraph) {
- for (Entry<String, Map<Date, ModuleNodeImpl>> node : moduleGraph.entrySet()) {
- String name = node.getKey();
-
- // Expects only one module revision
-
- Set<Edge> inEdges = node.getValue().values().iterator().next().getInEdges();
- Set<Edge> outEdges = node.getValue().values().iterator().next().getOutEdges();
-
- if (name.equals("a")) {
- assertEdgeCount(inEdges, 0, outEdges, 1);
- } else if (name.equals("b")) {
- assertEdgeCount(inEdges, 1, outEdges, 2);
- } else {
- assertEdgeCount(inEdges, 1, outEdges, 0);
- }
- }
- }
-
- private void assertEdgeCount(final Set<Edge> inEdges, final int i, final Set<Edge> outEdges, final int j) {
- assertThat(inEdges.size(), is(i));
- assertThat(outEdges.size(), is(j));
- }
-
- private void mockDependency(final ModuleBuilder a, final ModuleBuilder b) {
- ModuleImport imprt = mock(ModuleImport.class);
- doReturn(b.getName()).when(imprt).getModuleName();
- doReturn(b.getName()).when(imprt).getPrefix();
- doReturn(b.getRevision()).when(imprt).getRevision();
- a.getImports().put(b.getName(), imprt);
- }
-
- private void mockDependency(final Module a, final Module b) {
- ModuleImport imprt = mock(ModuleImport.class);
- doReturn(b.getName()).when(imprt).getModuleName();
- doReturn(b.getRevision()).when(imprt).getRevision();
- a.getImports().add(imprt);
- }
-
- private ModuleBuilder mockModuleBuilder(final String name, final Date rev) {
- ModuleBuilder a = mock(ModuleBuilder.class);
- doReturn(name).when(a).getName();
- Map<String, ModuleImport> map = new HashMap<>();
- doReturn(map).when(a).getImports();
- if (rev != null) {
- doReturn(rev).when(a).getRevision();
- }
- return a;
+ public void testSubmodules() {
+ assertSortedTo(of(fooNoRev, bar), bar, fooNoRev);
+ assertSortedTo(of(fooNoRev, bar), fooNoRev, bar);
}
- private Module mockModule(final String name, final Date rev) {
- Module a = mock(Module.class);
- doReturn(name).when(a).getName();
- Set<ModuleImport> set = Sets.newHashSet();
- doReturn(set).when(a).getImports();
- if (rev != null) {
- doReturn(rev).when(a).getRevision();
- }
- return a;
+ private static void assertSortedTo(final List<Module> expected, final Module... modules) {
+ assertEquals(expected, ModuleDependencySort.sort(modules));
}
}
Code Review / yangtools.git / blobdiff