Examples with DataType org.alien4cloud.tosca.model.types.DataType used on opensource projects

Example 1 with DataType

use of org.alien4cloud.tosca.model.types.DataType in project alien4cloud by alien4cloud.

the class DataTypesFetcher method getDataTypeDependency.

private static void getDataTypeDependency(Map<String, DataType> indexedDataTypes, String type, DataTypeFinder dataTypeFinder) {
    if (ToscaTypes.isPrimitive(type) || indexedDataTypes.containsKey(type)) {
        return;
    }
    DataType dataType = dataTypeFinder.findDataType(DataType.class, type);
    if (dataType == null) {
        dataType = dataTypeFinder.findDataType(PrimitiveDataType.class, type);
    }
    indexedDataTypes.put(type, dataType);
}

Example 2 with DataType

use of org.alien4cloud.tosca.model.types.DataType in project alien4cloud by alien4cloud.

the class ToscaTypeConverter method toPropertyValue.

@SuppressWarnings("unchecked")
public PropertyValue toPropertyValue(Object resolvedPropertyValue, PropertyDefinition propertyDefinition) {
    if (resolvedPropertyValue == null) {
        return null;
    }
    if (ToscaTypes.isSimple(propertyDefinition.getType())) {
        return new ScalarPropertyValue(resolvedPropertyValue.toString());
    }
    switch(propertyDefinition.getType()) {
        case ToscaTypes.MAP:
            if (resolvedPropertyValue instanceof Map) {
                Map<String, Object> map = (Map<String, Object>) resolvedPropertyValue;
                Map<String, Object> resultMap = Maps.newHashMap();
                map.forEach((key, value) -> resultMap.put(key, toPropertyValue(value, propertyDefinition.getEntrySchema())));
                return new ComplexPropertyValue(resultMap);
            } else {
                throw new IllegalStateException("Property value: expected type [" + Map.class.getSimpleName() + "] but got [" + resolvedPropertyValue.getClass().getName() + "]");
            }
        case ToscaTypes.LIST:
            if (resolvedPropertyValue instanceof Collection) {
                List list = (List) resolvedPropertyValue;
                List resultList = new LinkedList();
                for (Object item : list) {
                    resultList.add(toPropertyValue(item, propertyDefinition.getEntrySchema()));
                }
                return new ListPropertyValue(resultList);
            } else {
                throw new IllegalStateException("Property value: expected type [" + Collection.class.getSimpleName() + "] but got [" + resolvedPropertyValue.getClass().getName() + "]");
            }
        default:
            DataType dataType = findDataType(propertyDefinition.getType());
            if (dataType == null) {
                throw new NotFoundException("Data type  [" + propertyDefinition.getType() + "] cannot be found");
            }
            if (dataType.isDeriveFromSimpleType()) {
                return new ScalarPropertyValue(resolvedPropertyValue.toString());
            } else if (resolvedPropertyValue instanceof Map) {
                Map<String, Object> map = (Map<String, Object>) resolvedPropertyValue;
                /*
                 * Map<String, Object> resultMap = Maps.newHashMap();
                 * 
                 * map.forEach((key, value) -> {
                 * PropertyDefinition entryDefinition = dataType.getProperties().get(key);
                 * if(entryDefinition == null){
                 * throw new IllegalStateException("DataType [" + propertyDefinition.getType() + "] does not contains any definition for entry [" + key + "]");
                 * }
                 * resultMap.put(key, toPropertyValue(value, entryDefinition));
                 * });
                 * return new ComplexPropertyValue(resultMap);
                 */
                return new ComplexPropertyValue(map);
            } else {
                throw new IllegalStateException("Property value: expected type [" + propertyDefinition.getType() + "] but got [" + resolvedPropertyValue.getClass().getName() + "]");
            }
    }
}

Example 3 with DataType

use of org.alien4cloud.tosca.model.types.DataType in project alien4cloud by alien4cloud.

the class InputsMappingFileVariableResolverTest method check_inputs_mapping_can_be_parsed_when_no_variable.

@Test
public // Bad test
void check_inputs_mapping_can_be_parsed_when_no_variable() throws Exception {
    inputsMappingFileVariableResolverConfigured.customConverter(new ToscaTypeConverter((concreteType, id) -> {
        if (id.equals("datatype.complex_input_entry")) {
            DataType dataType = new DataType();
            dataType.setDeriveFromSimpleType(false);
            dataType.setProperties(// 
            ImmutableMap.of(// 
            "sub1", // 
            buildPropDef(ToscaTypes.MAP, ToscaTypes.STRING), // 
            "sub2", // 
            buildPropDef(ToscaTypes.MAP, ToscaTypes.STRING), // 
            "field01", // 
            buildPropDef(ToscaTypes.STRING)));
            return dataType;
        }
        return null;
    }));
    Map<String, PropertyValue> inputsMappingFileResolved = resolve("src/test/resources/alien/variables/inputs_mapping_without_variable.yml");
    assertThat(inputsMappingFileResolved).containsOnlyKeys("int_input", "float_input", "string_input", "complex_input");
    assertThat(inputsMappingFileResolved.get("int_input").getValue()).isEqualTo("10");
    assertThat(inputsMappingFileResolved.get("int_input")).isInstanceOf(ScalarPropertyValue.class);
    assertThat(inputsMappingFileResolved.get("float_input").getValue()).isEqualTo("3.14");
    assertThat(inputsMappingFileResolved.get("float_input")).isInstanceOf(ScalarPropertyValue.class);
    assertThat(inputsMappingFileResolved.get("string_input").getValue()).isEqualTo("text");
    assertThat(inputsMappingFileResolved.get("string_input")).isInstanceOf(ScalarPropertyValue.class);
    assertThat(inputsMappingFileResolved.get("complex_input")).isInstanceOf(ComplexPropertyValue.class);
    assertThat(inputsMappingFileResolved.get("complex_input")).isInstanceOf(ComplexPropertyValue.class);
    // 
    assertThat(inputsMappingFileResolved.get("complex_input").getValue()).isEqualTo(// 
    ImmutableMap.of("sub1", // 
    ImmutableMap.of(// 
    "subfield11", // 
    11, "subfield12", // 
    12), "sub2", // 
    ImmutableMap.of("subfield21", // 
    21), "field01", // 
    "01"));
}

Example 4 with DataType

use of org.alien4cloud.tosca.model.types.DataType in project alien4cloud by alien4cloud.

the class InputsMappingFileVariableResolverTest method check_uber_input_can_be_parsed.

@Ignore("Update when ToscaTypeConverter behavior is clearly defined")
@Test
public // Bad test
void check_uber_input_can_be_parsed() throws Exception {
    inputsPropertyDefinitions.put("uber_input", buildPropDef("datatype.uber"));
    /*
         * 
         * uber_input:
         * simple_var:
         * int_field: ${int_variable}
         * float_field: ${float_variable}
         * string_field: ${string_variable}
         * concat_field: ${int_variable}${float_variable}
         * simple_static:
         * int_field: 51
         * float_field: 16.64
         * string_field: "leffe"
         * complex:
         * complex_with_list: ${complex_with_list}
         * int_list:
         * - ${int_variable}
         * - ${int_variable}
         * float_list:
         * - ${float_variable}
         * - ${float_variable}
         * mix_list:
         * - ${int_variable}
         * - ${float_variable}
         * - ${string_variable}
         * static_mix_list:
         * - "jenlain"
         * - 16.64
         * - "kwak"
         * complex_with_var_in_leaf: ${complex_with_var_in_leaf}
         * 
         */
    inputsMappingFileVariableResolverConfigured.customConverter(new ToscaTypeConverter((concreteType, id) -> {
        DataType dataType = null;
        switch(id) {
            case "datatype.uber":
                dataType = new DataType();
                dataType.setDeriveFromSimpleType(false);
                dataType.setProperties(// 
                ImmutableMap.of(// 
                "simple_var", // 
                buildPropDef("datatype.uber.simple_var"), // 
                "complex", // 
                buildPropDef("datatype.uber.complex"), // 
                "simple_static", // 
                buildPropDef("datatype.uber.simple_static"), // 
                "complex_with_var_in_leaf", // 
                buildPropDef("datatype.uber.complex_with_var_in_leaf")));
                break;
            case "datatype.uber.simple_var":
                dataType = new DataType();
                dataType.setDeriveFromSimpleType(false);
                dataType.setProperties(// 
                ImmutableMap.of(// 
                "int_field", // 
                buildPropDef(ToscaTypes.INTEGER), // 
                "float_field", // 
                buildPropDef(ToscaTypes.FLOAT), // 
                "string_field", // 
                buildPropDef(ToscaTypes.STRING), // 
                "concat_field", // 
                buildPropDef(ToscaTypes.STRING)));
                break;
            case "datatype.uber.simple_static":
                dataType = new DataType();
                dataType.setDeriveFromSimpleType(false);
                dataType.setProperties(// 
                ImmutableMap.of(// 
                "int_field", // 
                buildPropDef(ToscaTypes.INTEGER), // 
                "float_field", // 
                buildPropDef(ToscaTypes.FLOAT), // 
                "string_field", // 
                buildPropDef(ToscaTypes.STRING)));
                break;
            case "datatype.uber.complex":
                dataType = new DataType();
                dataType.setDeriveFromSimpleType(false);
                dataType.setProperties(// 
                ImmutableMap.<String, PropertyDefinition>builder().put("complex_with_list", buildPropDef("datatype.uber.complex.complex_with_list")).put("int_list", // 
                buildPropDef(ToscaTypes.LIST, ToscaTypes.FLOAT)).put("float_list", // 
                buildPropDef(ToscaTypes.LIST, ToscaTypes.STRING)).put("mix_list", // 
                buildPropDef(ToscaTypes.LIST, ToscaTypes.STRING)).put("static_mix_list", buildPropDef(ToscaTypes.LIST, ToscaTypes.STRING)).build());
                break;
            case "datatype.uber.complex.complex_with_list":
                dataType = new DataType();
                dataType.setDeriveFromSimpleType(false);
                dataType.setProperties(// NEED TO BE
                ImmutableMap.<String, PropertyDefinition>builder().put("subfield1", buildPropDef(ToscaTypes.STRING)).put("subfield2", buildPropDef(ToscaTypes.MAP, buildPropDef(ToscaTypes.LIST, ToscaTypes.STRING))).build());
                break;
            case "datatype.uber.complex_with_var_in_leaf":
                dataType = new DataType();
                dataType.setDeriveFromSimpleType(false);
                dataType.setProperties(// 
                ImmutableMap.of("complex", // 
                buildPropDef(ToscaTypes.MAP, ToscaTypes.STRING)));
                break;
        }
        return dataType;
    }));
    Map<String, PropertyValue> inputsMappingFileResolved = resolve("src/test/resources/alien/variables/inputs_mapping_uber.yml");
    assertThat(inputsMappingFileResolved).containsOnlyKeys("uber_input");
    assertThat(inputsMappingFileResolved.get("uber_input")).isInstanceOf(ComplexPropertyValue.class);
    ComplexPropertyValue uberInput = (ComplexPropertyValue) inputsMappingFileResolved.get("uber_input");
    assertThat(sub(ScalarPropertyValue.class, uberInput, "simple_var", "string_field").getValue()).isEqualTo("text");
    assertThat(sub(ScalarPropertyValue.class, uberInput, "simple_var", "concat_field").getValue()).isEqualTo("13.14");
    assertThat(sub(ScalarPropertyValue.class, uberInput, "simple_static", "int_field").getValue()).isEqualTo("51");
    assertThat(sub(ScalarPropertyValue.class, uberInput, "simple_static", "float_field").getValue()).isEqualTo("16.64");
    assertThat(sub(ScalarPropertyValue.class, uberInput, "simple_static", "string_field").getValue()).isEqualTo("leffe");
    assertThat(sub(ListPropertyValue.class, uberInput, "complex", "int_list").getValue()).isEqualTo(Arrays.asList(new ScalarPropertyValue("1"), new ScalarPropertyValue("1")));
    assertThat(sub(ListPropertyValue.class, uberInput, "complex", "float_list").getValue()).hasSize(2);
    assertThat(sub(ListPropertyValue.class, uberInput, "complex", "mix_list").getValue()).hasSize(3);
    assertThat(sub(ListPropertyValue.class, uberInput, "complex", "static_mix_list").getValue()).hasSize(3);
    assertThat(sub(ListPropertyValue.class, uberInput, "complex", "complex_with_list", "subfield2", "sublist").getValue()).hasSize(3);
    assertThat(sub(ScalarPropertyValue.class, uberInput, "complex_with_var_in_leaf", "complex", "subfield").getValue()).isEqualTo("text");
}

Example 5 with DataType

use of org.alien4cloud.tosca.model.types.DataType in project alien4cloud by alien4cloud.

the class ToscaTypeConverterTest method findDataType.

@SneakyThrows
private static DataType findDataType(Class<? extends DataType> concreteType, String id) {
    switch(id) {
        case "alien.nodes.test.ComplexDataType":
            DataType dataType = new DataType();
            Map<String, PropertyDefinition> propertyDefinitionMap = Maps.newHashMap();
            new PropertyDefinition();
            propertyDefinitionMap.put("nested", buildPropDef("string"));
            propertyDefinitionMap.put("nested_array", buildPropDef("list", "string"));
            propertyDefinitionMap.put("nested_map", buildPropDef("map", "string"));
            dataType.setProperties(propertyDefinitionMap);
            dataType.setElementId("alien.nodes.test.ComplexDataType");
            return dataType;
        default:
            return null;
    }
}