binding/mdsal-binding-generator/src/test/java/org/opendaylight/mdsal/binding/generator/impl/DefaultBindingGeneratorTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
   3  * Copyright (c) 2021 PANTHEON.tech, s.r.o.
   4  *
   5  * This program and the accompanying materials are made available under the
   6  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   7  * and is available at http://www.eclipse.org/legal/epl-v10.html
   8  */
   9 package org.opendaylight.mdsal.binding.generator.impl;
  10
  11 import static org.hamcrest.CoreMatchers.instanceOf;
  12 import static org.hamcrest.MatcherAssert.assertThat;
  13 import static org.junit.Assert.assertEquals;
  14
  15 import java.util.List;
  16 import org.junit.AfterClass;
  17 import org.junit.BeforeClass;
  18 import org.junit.Test;
  19 import org.junit.runner.RunWith;
  20 import org.mockito.junit.MockitoJUnitRunner;
  21 import org.opendaylight.mdsal.binding.model.api.Enumeration;
  22 import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
  23 import org.opendaylight.mdsal.binding.model.api.GeneratedType;
  24 import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
  25 import org.opendaylight.mdsal.binding.model.api.MethodSignature;
  26 import org.opendaylight.mdsal.binding.model.api.ParameterizedType;
  27 import org.opendaylight.mdsal.binding.model.ri.Types;
  28 import org.opendaylight.mdsal.binding.yang.types.TypeProviderTest;
  29 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
  30 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
  31
  32 /**
  33  * General test suite revolving around {@link DefaultBindingGenerator}. This class holds tests originally aimed at
  34  * specific implementation methods, but now they really are all about integration testing.
  35  */
  36 @RunWith(MockitoJUnitRunner.class)
  37 public class DefaultBindingGeneratorTest {
  38     public static final String BASE_YANG_TYPES =
  39         "org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914";
  40     public static final String TEST_TYPE_PROVIDER =
  41         "org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.model.rev140912";
  42     public static final String TEST_TYPE_PROVIDER_B =
  43         "org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.type.provider.b.model.rev140915";
  44     public static final JavaTypeName CONSTRUCTION_TYPE_TEST =
  45         JavaTypeName.create(TEST_TYPE_PROVIDER, "ConstructionTypeTest");
  46
  47     public static EffectiveModelContext SCHEMA_CONTEXT;
  48     public static List<GeneratedType> TYPES;
  49
  50     @BeforeClass
  51     public static void beforeClass() {
  52         SCHEMA_CONTEXT = YangParserTestUtils.parseYangResources(TypeProviderTest.class,
  53             "/base-yang-types.yang", "/test-type-provider-b.yang", "/test-type-provider.yang");
  54         TYPES = DefaultBindingGenerator.generateFor(SCHEMA_CONTEXT);
  55     }
  56
  57     @AfterClass
  58     public static void afterClass() {
  59         SCHEMA_CONTEXT = null;
  60         TYPES = null;
  61     }
  62
  63     @Test
  64     public void javaTypeForSchemaDefinitionLeafrefToEnumTypeTest() {
  65         final var bData = assertGeneratedType(JavaTypeName.create(TEST_TYPE_PROVIDER_B, "TestTypeProviderBData"));
  66         final var bDataMethods = bData.getMethodDefinitions();
  67         assertEquals(8, bDataMethods.size());
  68
  69         final var bEnumType = assertGeneratedMethod(bDataMethods, "getEnum").getReturnType();
  70         assertThat(bEnumType, instanceOf(Enumeration.class));
  71         assertEquals(TEST_TYPE_PROVIDER + ".Foo.ResolveDirectUseOfEnum", bEnumType.getFullyQualifiedName());
  72
  73         final var bEnumsType = assertGeneratedMethod(bDataMethods, "getEnums").getReturnType();
  74
  75         assertThat(bEnumsType, instanceOf(ParameterizedType.class));
  76         final var enumsType = (ParameterizedType) bEnumsType;
  77
  78         assertEquals(Types.typeForClass(List.class), enumsType.getRawType());
  79         final var enumsTypeArgs = enumsType.getActualTypeArguments();
  80         assertEquals(1, enumsTypeArgs.length);
  81         assertEquals(TEST_TYPE_PROVIDER + ".Foo.ListOfEnums", enumsTypeArgs[0].getFullyQualifiedName());
  82     }
  83
  84     @Test
  85     public void generatedTypeForExtendedDefinitionTypeWithIdentityrefBaseTypeTest() {
  86         final var type = assertGeneratedMethod(CONSTRUCTION_TYPE_TEST, "getAesIdentityrefType").getReturnType();
  87         assertThat(type, instanceOf(ParameterizedType.class));
  88         final var pType = (ParameterizedType) type;
  89         assertEquals(Types.CLASS, pType.getRawType());
  90         final var pTypeArgs = pType.getActualTypeArguments();
  91         assertEquals(1, pTypeArgs.length);
  92         assertEquals(TEST_TYPE_PROVIDER + ".Aes", pTypeArgs[0].getFullyQualifiedName());
  93     }
  94
  95     @Test
  96     public void generatedTypeForExtendedDefinitionTypeWithLeafrefBaseTypeTest() {
  97         final var type = assertGeneratedMethod(CONSTRUCTION_TYPE_TEST, "getBarId").getReturnType();
  98         assertThat(type, instanceOf(GeneratedTransferObject.class));
  99         final var gto = (GeneratedTransferObject) type;
 100         assertEquals(JavaTypeName.create(BASE_YANG_TYPES, "YangInt16"), gto.getIdentifier());
 101     }
 102
 103     @Test
 104     public void generatedTypeForExtendedDefinitionTypeWithInnerExtendedTypeTest() {
 105         assertGTO(JavaTypeName.create(TEST_TYPE_PROVIDER, "ExtendedYangInt8"));
 106     }
 107
 108     @Test
 109     public void generatedTypeForExtendedDefinitionTypeTest() {
 110         assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangBoolean"));
 111         assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangEmpty"));
 112         assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangInt8"));
 113         assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangInt8Restricted"));
 114         assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangInt16"));
 115         assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangInt32"));
 116         assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangInt64"));
 117         assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangString"));
 118         assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangDecimal64"));
 119         assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangUint8"));
 120         assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangUint16"));
 121         assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangUint32"));
 122         assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangUint64"));
 123         assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangUnion"));
 124         assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangBinary"));
 125         assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangInstanceIdentifier"));
 126         assertGTO(JavaTypeName.create(BASE_YANG_TYPES, "YangBits"));
 127         assertEnumeration(JavaTypeName.create(BASE_YANG_TYPES, "YangEnumeration"));
 128     }
 129
 130     @Test
 131     public void provideGeneratedTOBuilderForUnionTypeDefWithInnerUnionTypesTest() {
 132         final var gto = assertGTO(JavaTypeName.create(TEST_TYPE_PROVIDER, "ComplexUnion"));
 133         assertEquals(3, gto.getProperties().size());
 134         assertEquals(List.of(), gto.getEnumerations());
 135         final var enclosed = gto.getEnclosedTypes();
 136         assertEquals(1, enclosed.size());
 137
 138         final var union1 = enclosed.get(0);
 139         assertThat(union1, instanceOf(GeneratedTransferObject.class));
 140         assertEquals(TEST_TYPE_PROVIDER + ".ComplexUnion.ComplexUnion$1", union1.getFullyQualifiedName());
 141         assertEquals(1, union1.getProperties().size());
 142         assertEquals(List.of(), union1.getEnclosedTypes());
 143
 144         final var enums = union1.getEnumerations();
 145         assertEquals(1, enums.size());
 146         assertEquals(TEST_TYPE_PROVIDER + ".ComplexUnion.ComplexUnion$1.Enumeration",
 147             enums.get(0).getFullyQualifiedName());
 148     }
 149
 150     @Test
 151     public void provideGeneratedTOBuilderForUnionTypeDefWithInnerUnionAndSimpleTypeTest() {
 152         final var gto = assertGTO(JavaTypeName.create(TEST_TYPE_PROVIDER, "ComplexStringIntUnion"));
 153         assertEquals(2, gto.getProperties().size());
 154         assertEquals(List.of(), gto.getEnumerations());
 155         assertEquals(List.of(), gto.getEnclosedTypes());
 156     }
 157
 158     @Test
 159     public void javaTypeForSchemaDefinitionForExtUnionWithSimpleTypesTest() {
 160         final var type = assertGeneratedMethod(
 161             JavaTypeName.create(TEST_TYPE_PROVIDER, "UseOfUnions"), "getSimpleIntTypesUnion").getReturnType();
 162         assertThat(type, instanceOf(GeneratedTransferObject.class));
 163         assertEquals(JavaTypeName.create(BASE_YANG_TYPES, "YangUnion"), type.getIdentifier());
 164     }
 165
 166     @Test
 167     public void javaTypeForSchemaDefinitionForExtUnionWithInnerUnionAndSimpleTypeTest() {
 168         final var type = assertGeneratedMethod(
 169             JavaTypeName.create(TEST_TYPE_PROVIDER, "UseOfUnions"), "getComplexStringIntUnion").getReturnType();
 170         assertThat(type, instanceOf(GeneratedTransferObject.class));
 171         assertEquals(JavaTypeName.create(TEST_TYPE_PROVIDER, "ComplexStringIntUnion"), type.getIdentifier());
 172     }
 173
 174     @Test
 175     public void javaTypeForSchemaDefinitionForExtComplexUnionWithInnerUnionTypesTest() {
 176         final var type = assertGeneratedMethod(
 177             JavaTypeName.create(TEST_TYPE_PROVIDER, "UseOfUnions"), "getComplexUnion").getReturnType();
 178         assertThat(type, instanceOf(GeneratedTransferObject.class));
 179         assertEquals(JavaTypeName.create(TEST_TYPE_PROVIDER, "ComplexUnion"), type.getIdentifier());
 180     }
 181
 182     @Test
 183     public void javaTypeForSchemaDefinitionIdentityrefExtTypeTest() {
 184         final var type = assertGeneratedMethod(JavaTypeName.create(TEST_TYPE_PROVIDER, "Foo"), "getCrypto")
 185             .getReturnType();
 186         assertThat(type, instanceOf(ParameterizedType.class));
 187         final var param = (ParameterizedType) type;
 188         assertEquals(JavaTypeName.create(Class.class), param.getIdentifier());
 189         final var params = param.getActualTypeArguments();
 190         assertEquals(1, params.length);
 191         assertEquals(Types.wildcardTypeFor(JavaTypeName.create(TEST_TYPE_PROVIDER, "CryptoAlg")), params[0]);
 192     }
 193
 194     @Test
 195     public void javaTypeForSchemaDefinitionEmptyStringPatternTypeTest() {
 196         final var restrictions = assertGTO(JavaTypeName.create(TEST_TYPE_PROVIDER, "EmptyPatternString"))
 197             .getRestrictions();
 198         final var patterns = restrictions.getPatternConstraints();
 199         assertEquals(1, patterns.size());
 200         final var pattern = patterns.get(0);
 201         assertEquals("", pattern.getRegularExpressionString());
 202         assertEquals("^(?:)$", pattern.getJavaPatternString());
 203     }
 204
 205     private static MethodSignature assertGeneratedMethod(final JavaTypeName typeName, final String methodName) {
 206         return assertGeneratedMethod(assertGeneratedType(typeName).getMethodDefinitions(), methodName);
 207     }
 208
 209     private static MethodSignature assertGeneratedMethod(final List<MethodSignature> methods, final String name) {
 210         return methods.stream().filter(method -> name.equals(method.getName()))
 211             .findFirst()
 212             .orElseThrow(() -> new AssertionError("Method " + name + " not present"));
 213     }
 214
 215     private static GeneratedType assertGeneratedType(final JavaTypeName name) {
 216         return TYPES.stream()
 217             .filter(type -> name.equals(type.getIdentifier()))
 218             .findFirst()
 219             .orElseThrow(() -> new AssertionError("Generated type " + name + " not present"));
 220     }
 221
 222     private static Enumeration assertEnumeration(final JavaTypeName name) {
 223         final var type = assertGeneratedType(name);
 224         assertThat(type, instanceOf(Enumeration.class));
 225         return (Enumeration) type;
 226     }
 227
 228     private static GeneratedTransferObject assertGTO(final JavaTypeName name) {
 229         final var type = assertGeneratedType(name);
 230         assertThat(type, instanceOf(GeneratedTransferObject.class));
 231         return (GeneratedTransferObject) type;
 232     }
 233 }