binding/mdsal-binding-generator/src/test/java/org/opendaylight/mdsal/binding/yang/types/TypeProviderTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.mdsal.binding.yang.types;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertNotNull;
  12 import static org.junit.Assert.assertTrue;
  13
  14 import com.google.common.collect.Range;
  15 import java.util.List;
  16 import java.util.Optional;
  17 import org.junit.AfterClass;
  18 import org.junit.BeforeClass;
  19 import org.junit.Ignore;
  20 import org.junit.Test;
  21 import org.junit.runner.RunWith;
  22 import org.mockito.Mock;
  23 import org.mockito.junit.MockitoJUnitRunner;
  24 import org.opendaylight.mdsal.binding.generator.BindingGeneratorUtil;
  25 import org.opendaylight.mdsal.binding.model.api.ConcreteType;
  26 import org.opendaylight.mdsal.binding.model.api.Enumeration;
  27 import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
  28 import org.opendaylight.mdsal.binding.model.api.Restrictions;
  29 import org.opendaylight.mdsal.binding.model.api.Type;
  30 import org.opendaylight.yangtools.yang.common.QName;
  31 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
  32 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  33 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
  34 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
  35 import org.opendaylight.yangtools.yang.model.api.Module;
  36 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
  37 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  38 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  39 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
  40 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
  41
  42 /**
  43  * Test suite for testing public methods in TypeProviderImpl class.
  44  *
  45  * @see org.opendaylight.mdsal.binding.yang.types.AbstractTypeProvider
  46  * @author Lukas Sedlak &lt;lsedlak@cisco.com&gt;
  47  */
  48 // FIXME: rewrite tests without TypeProvider interface
  49 @Ignore
  50 @RunWith(MockitoJUnitRunner.class)
  51 public class TypeProviderTest {
  52     static EffectiveModelContext SCHEMA_CONTEXT;
  53     static Module TEST_TYPE_PROVIDER;
  54
  55     @Mock
  56     public SchemaPath schemaPath;
  57
  58     @Mock
  59     public SchemaNode schemaNode;
  60
  61     @BeforeClass
  62     public static void beforeClass() {
  63         SCHEMA_CONTEXT = YangParserTestUtils.parseYangResources(TypeProviderTest.class,
  64             "/base-yang-types.yang", "/test-type-provider-b.yang", "/test-type-provider.yang");
  65         TEST_TYPE_PROVIDER = resolveModule("test-type-provider");
  66     }
  67
  68     @AfterClass
  69     public static void afterClass() {
  70         TEST_TYPE_PROVIDER = null;
  71         SCHEMA_CONTEXT = null;
  72     }
  73
  74     private static Module resolveModule(final String moduleName) {
  75         return SCHEMA_CONTEXT.findModules(moduleName).iterator().next();
  76     }
  77
  78     private static LeafSchemaNode provideLeafNodeFromTopLevelContainer(final Module module, final String containerName,
  79             final String leafNodeName) {
  80         final QName containerNode = QName.create(module.getQNameModule(), containerName);
  81         final DataSchemaNode rootNode = module.findDataChildByName(containerNode).get();
  82         assertTrue(rootNode instanceof DataNodeContainer);
  83
  84         final QName leafNode = QName.create(module.getQNameModule(), leafNodeName);
  85         final DataNodeContainer rootContainer = (DataNodeContainer) rootNode;
  86         final DataSchemaNode node = rootContainer.findDataChildByName(leafNode).get();
  87         assertTrue(node instanceof LeafSchemaNode);
  88         return (LeafSchemaNode) node;
  89     }
  90
  91     @Test
  92     public void javaTypeForSchemaDefinitionExtTypeTest() {
  93         final AbstractTypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
  94         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo",
  95             "yang-int8-type");
  96
  97         final TypeDefinition<?> leafType = leaf.getType();
  98         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
  99         assertNotNull(result);
 100         assertTrue(result instanceof GeneratedTransferObject);
 101
 102         final GeneratedTransferObject genTO = (GeneratedTransferObject) result;
 103         assertEquals("base-yang-types", genTO.getModuleName());
 104         assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914",
 105             genTO.getPackageName());
 106         assertEquals("YangInt8", genTO.getName());
 107         assertEquals(1, genTO.getProperties().size());
 108     }
 109
 110     @Test
 111     public void javaTypeForSchemaDefinitionRestrictedExtTypeTest() {
 112         final AbstractTypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 113         final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo",
 114             "restricted-int8-type");
 115
 116         final TypeDefinition<?> leafType = leaf.getType();
 117         final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(leafType);
 118
 119         final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf, restrictions);
 120         assertNotNull(result);
 121         assertTrue(result instanceof GeneratedTransferObject);
 122
 123         final GeneratedTransferObject genTO = (GeneratedTransferObject) result;
 124         assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914",
 125             genTO.getPackageName());
 126         assertEquals("YangInt8Restricted", genTO.getName());
 127         assertEquals(1, genTO.getProperties().size());
 128         final Optional<? extends RangeConstraint<?>> rangeConstraints = genTO.getRestrictions().getRangeConstraint();
 129
 130         assertTrue(rangeConstraints.isPresent());
 131         final Range<?> constraint = rangeConstraints.get().getAllowedRanges().asRanges().iterator().next();
 132         assertEquals((byte) 1, constraint.lowerEndpoint());
 133         assertEquals((byte) 100, constraint.upperEndpoint());
 134     }
 135
 136     @Test
 137     public void javaTypeForSchemaDefinitionEnumExtTypeTest() {
 138         final AbstractTypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 139         LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo", "resolve-enum-leaf");
 140         TypeDefinition<?> leafType = leaf.getType();
 141         Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 142         assertNotNull(result);
 143         assertTrue(result instanceof Enumeration);
 144
 145         final Enumeration enumType = (Enumeration) result;
 146         final List<Enumeration.Pair> enumValues = enumType.getValues();
 147         assertTrue(!enumValues.isEmpty());
 148         assertEquals("a", enumValues.get(0).getName());
 149         assertEquals("b", enumValues.get(1).getName());
 150         assertEquals("A", enumValues.get(0).getMappedName());
 151         assertEquals("B", enumValues.get(1).getMappedName());
 152
 153         leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "foo", "resolve-direct-use-of-enum");
 154         leafType = leaf.getType();
 155         result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 156         assertNotNull(result);
 157         assertTrue(result instanceof ConcreteType);
 158
 159         assertEquals("java.lang", result.getPackageName());
 160         assertEquals("Enum", result.getName());
 161     }
 162
 163     @Test
 164     public void javaTypeForSchemaDefinitionLeafrefExtTypeTest() {
 165         final AbstractTypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 166         LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(TEST_TYPE_PROVIDER, "bar", "leafref-value");
 167         TypeDefinition<?> leafType = leaf.getType();
 168         final Type leafrefResolvedType1 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 169         assertNotNull(leafrefResolvedType1);
 170         assertTrue(leafrefResolvedType1 instanceof GeneratedTransferObject);
 171
 172         final Module module = resolveModule("test-type-provider-b");
 173         final QName leafNode = QName.create(module.getQNameModule(), "id");
 174         final DataSchemaNode rootNode = module.findDataChildByName(leafNode).get();
 175         assertNotNull("leaf id is not present in root of module " + module.getName(), rootNode);
 176         assertTrue(rootNode instanceof LeafSchemaNode);
 177         leaf = (LeafSchemaNode) rootNode;
 178         leafType = leaf.getType();
 179
 180         final Type leafrefResolvedType2 = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 181         assertNotNull(leafrefResolvedType2);
 182         assertTrue(leafrefResolvedType2 instanceof GeneratedTransferObject);
 183     }
 184
 185     @Test
 186     public void javaTypeForSchemaDefinitionConditionalLeafrefTest() {
 187         final AbstractTypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 188         final Module module = resolveModule("test-type-provider-b");
 189
 190         final QName leafrefNode = QName.create(module.getQNameModule(), "conditional-leafref");
 191         final DataSchemaNode condLeaf = module.findDataChildByName(leafrefNode).get();
 192         assertTrue(condLeaf instanceof LeafSchemaNode);
 193         final LeafSchemaNode leaf = (LeafSchemaNode) condLeaf;
 194         final TypeDefinition<?> leafType = leaf.getType();
 195
 196         final Type resultType = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 197         assertNotNull(resultType);
 198         assertTrue(resultType instanceof ConcreteType);
 199         assertEquals("java.lang", resultType.getPackageName());
 200         assertEquals("Object", resultType.getName());
 201     }
 202
 203     @Test(expected = IllegalArgumentException.class)
 204     public void javaTypeForSchemaDefinitionInvalidLeafrefPathTest() {
 205         final AbstractTypeProvider provider = new CodegenTypeProvider(SCHEMA_CONTEXT);
 206         final Module module = resolveModule("test-type-provider-b");
 207
 208         final QName leafrefNode = QName.create(module.getQNameModule(), "unreslovable-leafref");
 209         final DataSchemaNode condLeaf = module.findDataChildByName(leafrefNode).get();
 210         assertTrue(condLeaf instanceof LeafSchemaNode);
 211         final LeafSchemaNode leaf = (LeafSchemaNode) condLeaf;
 212         final TypeDefinition<?> leafType = leaf.getType();
 213
 214         provider.javaTypeForSchemaDefinitionType(leafType, leaf);
 215     }
 216 }