<artifactId>sdc-tosca</artifactId>
<name>sdc-sdc-tosca</name>
<description>SDC Tosca Parser JAR file for use by consumers</description>
- <version>1.4.4-SNAPSHOT</version>
+ <version>1.4.5-SNAPSHOT</version>
<packaging>jar</packaging>
<properties>
<dependency>
<groupId>org.onap.sdc.jtosca</groupId>
<artifactId>jtosca</artifactId>
- <version>1.4.4</version>
+ <version>1.4.5-SNAPSHOT</version>
</dependency>
<version>1.10.19</version>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <version>4.11</version>
+ <scope>test</scope>
+ </dependency>
- </dependencies>
+ </dependencies>
<reporting>
<plugins>
import java.util.Map;
import org.apache.commons.lang3.tuple.Pair;
-import org.onap.sdc.tosca.parser.impl.SdcTypes;
-import org.onap.sdc.tosca.parser.impl.FilterType;
+import org.onap.sdc.tosca.parser.enums.SdcTypes;
+import org.onap.sdc.tosca.parser.enums.FilterType;
import org.onap.sdc.toscaparser.api.*;
import org.onap.sdc.toscaparser.api.elements.InterfacesDef;
import org.onap.sdc.toscaparser.api.elements.Metadata;
* @param pathToPropertyLeafValue - the full path of the required property.
* @return the leaf value as Object, or null if there's no such property. It's up to the caller to cast it to a proper type.
*/
- public Object getNodeTemplatePropertyAsObject(NodeTemplate nodeTemplate, String pathToPropertyLeafValue);
+ public Object getNodeTemplatePropertyValueAsObject(NodeTemplate nodeTemplate, String pathToPropertyLeafValue);
/**
* Get any property leaf value for a group definition by full path separated by #.
* @param policyTypeName the name of the policy type
* @return the list of the policies
*/
-
public List<Policy> getPoliciesOfOriginOfNodeTemplateByToscaPolicyType(NodeTemplate nodeTemplate, String policyTypeName);
+ List<Policy> getPoliciesOfOriginOfNodeTemplateByToscaPolicyType(NodeTemplate nodeTemplate, String policyTypeName);
/**
* Get all the node templates of the topology template, which are the targets of the policy specified by name
* @param policyName the name of the policy
* @return the list of the node templates
*/
- public List<NodeTemplate> getPolicyTargetsFromTopologyTemplate(String policyName);
+ List<NodeTemplate> getPolicyTargetsFromTopologyTemplate(String policyName);
/**
* Get all the node templates of the origin component (nested topology template) of node template, which are the targets of the policy specified by name
* @param policyName the name of the policy
* @return the list of the node templates
*/
- public List<NodeTemplate> getPolicyTargetsFromOrigin(NodeTemplate nodeTemplate, String policyName);
+ List<NodeTemplate> getPolicyTargetsFromOrigin(NodeTemplate nodeTemplate, String policyName);
/**
* Get the node template of the topology template specified by name
* @param nodeTemplateName the name of the node template
* @return the node template
*/
- public NodeTemplate getNodeTemplateByName(String nodeTemplateName);
+ NodeTemplate getNodeTemplateByName(String nodeTemplateName);
/**
* Get all the policies, which contain the specified node template as a target
* @param targetNode the node template
* @return the list of the policies
*/
-
public List<Policy> getPoliciesOfTarget(NodeTemplate targetNode);
+ List<Policy> getPoliciesOfTarget(NodeTemplate targetNode);
/**
* Get all the policies of the specified type, which contain the specified node template as a target
* @param policyTypeName the name of the policy type
* @return the list of the policies
*/
-
public List<Policy> getPoliciesOfTargetByToscaPolicyType(NodeTemplate nodeTemplate, String policyTypeName);
+ List<Policy> getPoliciesOfTargetByToscaPolicyType(NodeTemplate nodeTemplate, String policyTypeName);
/**
* Get all the groups of the origin component (nested topology template) of the node template
* @param nodeTemplate the node template
* @return the list of the groups
*/
- public ArrayList<Group> getGroupsOfOriginOfNodeTemplate(NodeTemplate nodeTemplate);
+ ArrayList<Group> getGroupsOfOriginOfNodeTemplate(NodeTemplate nodeTemplate);
/**
* Get all groups of this of the main topology template (either VF or service) by specified tosca group type
* @param groupType the group type
* @return the list of the groups
*/
- public ArrayList<Group> getGroupsOfTopologyTemplateByToscaGroupType(String groupType);
+ ArrayList<Group> getGroupsOfTopologyTemplateByToscaGroupType(String groupType);
/**
* Get all groups of this of the main topology template (either VF or service)
* @return the list of the groups
*/
- public ArrayList<Group> getGroupsOfTopologyTemplate();
+ ArrayList<Group> getGroupsOfTopologyTemplate();
/**
* Get all groups of this of the origin component (nested topology template) of the node template by specified tosca group type
* @param groupType the group type
* @return the list of the groups
*/
- public ArrayList<Group> getGroupsOfOriginOfNodeTemplateByToscaGroupType(NodeTemplate nodeTemplate, String groupType);
+ ArrayList<Group> getGroupsOfOriginOfNodeTemplateByToscaGroupType(NodeTemplate nodeTemplate, String groupType);
/**
* Get members of the group belongs to the main topology template (either VF or service) by group name
* @param groupName the name of the group
* @return the list of the node templates
*/
- public List<NodeTemplate> getGroupMembersFromTopologyTemplate(String groupName);
+ List<NodeTemplate> getGroupMembersFromTopologyTemplate(String groupName);
/**
* Get members of the group belongs to the origin component (nested topology template) of the node template by group name
* @param groupName the name of the group
* @return the list of the node templates
*/
- public List<NodeTemplate> getGroupMembersOfOriginOfNodeTemplate(NodeTemplate nodeTemplate, String groupName);
+ List<NodeTemplate> getGroupMembersOfOriginOfNodeTemplate(NodeTemplate nodeTemplate, String groupName);
/**
* Get inputs of the topology template including existing annotations
* @return the list of the inputs
*/
- public List<Input> getInputsWithAnnotations();
+ List<Input> getInputsWithAnnotations();
/**
* Get all interface details for given node template.<br>
* @return Map that contains the list of all interfaces and their definitions.
* If none found, an empty map will be returned.
*/
- public Map<String, List<InterfacesDef>> getInterfacesOf(NodeTemplate nt);
+ Map<String, List<InterfacesDef>> getInterfacesOf(NodeTemplate nt);
/**
* Get all interface names for given node template.<br>
* @return List that contains the definitions of given interface name.
* If none found, an empty list will be returned.
*/
- public List<InterfacesDef> getInterfaceDetails(NodeTemplate nt, String interfaceName);
+ List<InterfacesDef> getInterfaceDetails(NodeTemplate nt, String interfaceName);
/**
* Get all operation names for given node template and interface name.<br>
* @return List that contains the name of all operations for a given node template and interface name.
* If none found, an empty list will be returned.
*/
- public List<String> getAllInterfaceOperations(NodeTemplate nt, String interfaceName);
+ List<String> getAllInterfaceOperations(NodeTemplate nt, String interfaceName);
/**
* Get interface details for a given node template, interface name and operation name.<br>
* @return InterfaceDef representing the operation details.
* If none found, null will be returned.
*/
- public InterfacesDef getInterfaceOperationDetails(NodeTemplate nt, String interfaceName, String operationName);
+ InterfacesDef getInterfaceOperationDetails(NodeTemplate nt, String interfaceName, String operationName);
+ /**
+ * Get property value for a property of given node template.<br>
+ * @param propertyNamePath valid name of property for search.<br>
+ * To find value in the datatype with datatype entry schema, the property name should be defined with # delimiter
+ * @param nodeTemplatePath path to the model node template that property value will be searched.<br>
+ * Path is based on the collection of the node templates names delimited by #.
+ * @return List of property values. If none found, empty list will be returned.
+ */
+ List<String> getPropertyLeafValueByPropertyNamePathAndNodeTemplatePath(String propertyNamePath, String nodeTemplatePath);
+
+ boolean isNodeTypeSupported(NodeTemplate nodeTemplate);
}
\ No newline at end of file
-package org.onap.sdc.tosca.parser.impl;
+package org.onap.sdc.tosca.parser.enums;
public enum FilterType {
-package org.onap.sdc.tosca.parser.impl;
+package org.onap.sdc.tosca.parser.enums;
public enum JToscaValidationIssueType {
CRITICAL,
--- /dev/null
+package org.onap.sdc.tosca.parser.enums;
+
+
+import java.util.Arrays;
+import java.util.NoSuchElementException;
+
+import static org.onap.sdc.tosca.parser.enums.PropertySchemaType.PropertySchemaComplexity.Complex;
+import static org.onap.sdc.tosca.parser.enums.PropertySchemaType.PropertySchemaComplexity.DataType;
+import static org.onap.sdc.tosca.parser.enums.PropertySchemaType.PropertySchemaComplexity.Simple;
+
+public enum PropertySchemaType {
+
+ STRING(Simple, "string"),
+ INTEGER(Simple, "integer"),
+ BOOLEAN(Simple, "boolean"),
+ FLOAT(Simple, "float"),
+ NUMBER(Simple, "number"),
+ TIMESTAMP(Simple, "timestamp"),
+ RANGE(Simple, "range"),
+ VERSION(Simple, "version"),
+ SCALAR_UNIT_SIZE(Simple, "scalar-unit.size"),
+ SCALAR_UNIT_TIME(Simple, "scalar-unit.time"),
+ SCALAR_UNIT_FREQUENCY(Simple, "scalar-unit.frequency"),
+ LIST(Complex, "list"),
+ MAP(Complex, "map"),
+ DATATYPE(DataType, "datatypes");
+
+ private PropertySchemaComplexity complexity;
+ private String schemaType;
+
+ PropertySchemaType(PropertySchemaComplexity complexity, String schemaType) {
+ this.complexity = complexity;
+ this.schemaType = schemaType;
+ }
+
+ public PropertySchemaComplexity getSchemaTypeComplexity() {
+ return complexity;
+ }
+
+ public String getSchemaTypeName() {
+ return schemaType;
+ }
+
+ public enum PropertySchemaComplexity {
+ Simple, Complex, DataType
+ }
+
+ public static PropertySchemaType getEnumByValue(String type){
+ if (type == null) {
+ throwNoSuchElementException(null);
+ }
+
+ if (type.contains(DATATYPE.getSchemaTypeName())) {
+ return DATATYPE;
+ }
+ PropertySchemaType propertySchemaType = Arrays.stream(PropertySchemaType.values())
+ .filter(v->v.getSchemaTypeName().equals(type))
+ .findFirst().orElse(null);
+ if (propertySchemaType == null) {
+ throwNoSuchElementException(type);
+ }
+ return propertySchemaType;
+ }
+
+ private static void throwNoSuchElementException(String type) {
+ throw new NoSuchElementException(String.format("Value %s is not defined in %s", type, PropertySchemaType.class.getName()));
+ }
+
+}
* ============LICENSE_END=========================================================
*/
-package org.onap.sdc.tosca.parser.impl;
+package org.onap.sdc.tosca.parser.enums;
import java.util.Arrays;
import java.util.List;
private static List<String> complexTypes = Arrays.asList(VF, PNF, CR, SERVICE, CVFC).stream().map(SdcTypes::getValue).collect(Collectors.toList());
- private SdcTypes(String value) {
+ SdcTypes(String value) {
this.value = value;
}
package org.onap.sdc.tosca.parser.impl;
import static java.util.stream.Collectors.toList;
+
import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import org.apache.commons.lang3.tuple.Pair;
import org.onap.sdc.tosca.parser.api.ISdcCsarHelper;
import org.onap.sdc.tosca.parser.config.ConfigurationManager;
+import org.onap.sdc.tosca.parser.enums.FilterType;
+import org.onap.sdc.tosca.parser.enums.PropertySchemaType;
+import org.onap.sdc.tosca.parser.enums.SdcTypes;
import org.onap.sdc.tosca.parser.utils.GeneralUtility;
+import org.onap.sdc.tosca.parser.utils.PropertyUtils;
import org.onap.sdc.tosca.parser.utils.SdcToscaUtility;
import org.onap.sdc.toscaparser.api.CapabilityAssignment;
import org.onap.sdc.toscaparser.api.CapabilityAssignments;
@Override
//Sunny flow - covered with UT, flat and nested
public String getNodeTemplatePropertyLeafValue(NodeTemplate nodeTemplate, String leafValuePath) {
- if (nodeTemplate == null) {
- log.error("getNodeTemplatePropertyLeafValue - nodeTemplate is null");
- return null;
- }
- if (GeneralUtility.isEmptyString(leafValuePath)) {
- log.error("getNodeTemplatePropertyLeafValue - leafValuePath is null or empty");
- return null;
- }
- String[] split = getSplittedPath(leafValuePath);
- LinkedHashMap<String, Property> properties = nodeTemplate.getProperties();
- Object property = processProperties(split, properties);
- return property == null || property instanceof Function ? null : String.valueOf(property);
+ Object value = getNodeTemplatePropertyValueAsObject(nodeTemplate, leafValuePath);
+ return value == null || value instanceof Function ? null : String.valueOf(value);
}
@Override
- public Object getNodeTemplatePropertyAsObject(NodeTemplate nodeTemplate, String leafValuePath) {
+ public Object getNodeTemplatePropertyValueAsObject(NodeTemplate nodeTemplate, String leafValuePath) {
if (nodeTemplate == null) {
- log.error("getNodeTemplatePropertyAsObject - nodeTemplate is null");
+ log.error("getNodeTemplatePropertyValueAsObject - nodeTemplate is null");
return null;
}
if (GeneralUtility.isEmptyString(leafValuePath)) {
- log.error("getNodeTemplatePropertyAsObject - leafValuePath is null or empty");
+ log.error("getNodeTemplatePropertyValueAsObject - leafValuePath is null or empty");
return null;
}
String[] split = getSplittedPath(leafValuePath);
LinkedHashMap<String, Property> properties = nodeTemplate.getProperties();
- return processProperties(split, properties);
+ return PropertyUtils.processProperties(split, properties);
}
public Map<String, Map<String, Object>> getCpPropertiesFromVfcAsObject(NodeTemplate vfc) {
if (findFirst.isPresent()) {
Input input = findFirst.get();
Object current = input.getDefault();
- Object property = iterateProcessPath(2, current, split);
+ Object property = PropertyUtils.iterateProcessPath(2, current, split);
return property == null || property instanceof Function? null : String.valueOf(property);
}
}
if (findFirst.isPresent()) {
Input input = findFirst.get();
Object current = input.getDefault();
- return iterateProcessPath(2, current, split);
+ return PropertyUtils.iterateProcessPath(2, current, split);
}
}
log.error("getServiceInputLeafValueOfDefaultAsObject - value not found");
return null;
}
- @SuppressWarnings({ "unchecked", "rawtypes" })
- private Object iterateProcessPath(Integer index, Object current, String[] split) {
- if (current == null) {
- log.error("iterateProcessPath - this input has no default");
- return null;
- }
- if (split.length > index) {
- for (int i = index; i < split.length; i++) {
- if (current instanceof Map) {
- current = ((Map<String, Object>) current).get(split[i]);
- } else if (current instanceof List) {
- current = ((List) current).get(0);
- i--;
- }
- else {
- log.error("iterateProcessPath - found an unexpected leaf where expected to find a complex type");
- return null;
- }
- }
- }
- if (current != null) {
- return current;
- }
- log.error("iterateProcessPath - Path not Found");
- return null;
- }
-
- private String[] getSplittedPath(String inputLeafValuePath) {
- return inputLeafValuePath.split(PATH_DELIMITER);
+ private String[] getSplittedPath(String leafValuePath) {
+ return leafValuePath.split(PATH_DELIMITER);
}
String[] split = getSplittedPath(leafValuePath);
LinkedHashMap<String, Property> properties = group.getProperties();
- Object property = processProperties(split, properties);
+ Object property = PropertyUtils.processProperties(split, properties);
return property == null || property instanceof Function? null : String.valueOf(property);
}
String[] split = getSplittedPath(leafValuePath);
LinkedHashMap<String, Property> properties = group.getProperties();
- return processProperties(split, properties);
+ return PropertyUtils.processProperties(split, properties);
}
@Override
public List<NodeTemplate> getNodeTemplateBySdcType(NodeTemplate parentNodeTemplate, SdcTypes sdcType) {
return getNodeTemplateBySdcType(parentNodeTemplate, sdcType, false);
}
+
+ public boolean isNodeTypeSupported(NodeTemplate nodeTemplate) {
+ SdcTypes[] supportedTypes = SdcTypes.values();
+ return Arrays.stream(supportedTypes)
+ .anyMatch(v->nodeTemplate.getMetaData().getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)
+ .equals(v.getValue()));
+ }
private List<NodeTemplate> getNodeTemplateBySdcType(NodeTemplate parentNodeTemplate, SdcTypes sdcType, boolean isVNF) {
String[] split = getSplittedPath(pathToPropertyLeafValue);
LinkedHashMap<String, Property> properties = capability.getProperties();
- Object property = processProperties(split, properties);
+ Object property = PropertyUtils.processProperties(split, properties);
return property == null || property instanceof Function ? null : String.valueOf(property);
}
}
}
- private Object processProperties(String[] split, LinkedHashMap<String, Property> properties) {
- Optional<Entry<String, Property>> findFirst = properties.entrySet().stream().filter(x -> x.getKey().equals(split[0])).findFirst();
- if (findFirst.isPresent()) {
- Property property = findFirst.get().getValue();
- Object current = property.getValue();
- return iterateProcessPath(1, current, split);
- }
- String propName = (split != null && split.length > 0 ? split[0] : null);
- log.error("processProperties - property {} not found", propName);
- return null;
- }
-
@Override
public Map<String, List<InterfacesDef>> getInterfacesOf(NodeTemplate nt){
if (nt == null) {
return null;
}
- @Override
+ @Override
+ public List<String> getPropertyLeafValueByPropertyNamePathAndNodeTemplatePath(String propertyNamePath, String nodeTemplatePath) {
+ log.info("A new request is received: property path is [{}], node template path is [{}]",
+ propertyNamePath, nodeTemplatePath);
+
+ List<String> propertyValuesList;
+
+ if (StringUtils.isEmpty(nodeTemplatePath) || StringUtils.isEmpty(propertyNamePath)) {
+ log.error("One of parameters is empty or null: property path is [{}], node template path is [{}]",
+ propertyNamePath, nodeTemplatePath);
+ propertyValuesList = Collections.emptyList();
+ }
+ else {
+ String[] nodeTemplates = getSplittedPath(nodeTemplatePath);
+ propertyValuesList = getPropertyFromInternalNodeTemplate(getNodeTemplateByName(nodeTemplates[0]), 1, nodeTemplates, propertyNamePath);
+ log.info("Found property value {} by path [{}] for node template [{}]",
+ propertyValuesList, propertyNamePath, nodeTemplatePath);
+ }
+ return propertyValuesList;
+ }
+
+ private List<String> getPropertyFromInternalNodeTemplate(NodeTemplate parent, int index,
+ String[] nodeTemplatePath, String propertyPath) {
+ List<String> propertyValuesList;
+ if (parent == null) {
+ log.error("Node template {} is not found, the request will be rejected", nodeTemplatePath[index]);
+ propertyValuesList = Collections.emptyList();
+ }
+ else if (nodeTemplatePath.length <= index) {
+ log.debug("Stop NODE TEMPLATE searching");
+ propertyValuesList = getSimpleOrListPropertyValue(parent, propertyPath);
+ }
+ else {
+ log.debug("Node template {} is found with name {}", nodeTemplatePath[index], parent.getName());
+ NodeTemplate childNT = getChildNodeTemplateByName(parent, nodeTemplatePath[index]);
+
+ if (childNT == null || !isNodeTypeSupported(childNT)) {
+ log.error("Unsupported or not found node template named {}, the request will be rejected",
+ nodeTemplatePath[index]);
+ propertyValuesList = Collections.emptyList();
+ }
+ else {
+ propertyValuesList = getPropertyFromInternalNodeTemplate(childNT, index + 1, nodeTemplatePath,
+ propertyPath);
+ }
+ }
+ return propertyValuesList;
+ }
+
+
+
+ private List<String> getSimpleOrListPropertyValue(NodeTemplate nodeTemplate, String propertyPath) {
+ List<String> propertyValueList;
+ String[] path = getSplittedPath(propertyPath);
+ Property property = getNodeTemplatePropertyObjectByName(nodeTemplate, path[0]);
+
+ if (PropertyUtils.isPropertyTypeSimpleOrListOfSimpleTypes(nodeTemplate, path, property)) {
+ //the requested property type is either simple or list of simple types
+ PropertySchemaType propertyType = PropertySchemaType.getEnumByValue(property.getType());
+ if (propertyType == PropertySchemaType.LIST &&
+ PropertyUtils.isDataPropertyType((String)property.getEntrySchema()
+ .get(SdcPropertyNames.PROPERTY_NAME_TYPE))) {
+ //cover the case when a type of property "path[0]' is list of data types
+ // and the requested property is an internal simple property of this data type
+ propertyValueList = calculatePropertyValue(getNodeTemplatePropertyValueAsObject(nodeTemplate, path[0]), path, nodeTemplate.getName());
+ }
+ else {
+ //the requested property is simple type or list of simple types
+ propertyValueList = calculatePropertyValue(getNodeTemplatePropertyValueAsObject(nodeTemplate, propertyPath), null, nodeTemplate.getName());
+ }
+ }
+ else {
+ log.error("The type of property {} on node {} is neither simple nor list of simple objects, the request will be rejected",
+ propertyPath, nodeTemplate.getName());
+ propertyValueList = Collections.emptyList();
+ }
+ return propertyValueList;
+ }
+
+ private List<String> calculatePropertyValue(Object valueAsObject, String path[], String nodeName) {
+ if (valueAsObject == null || valueAsObject instanceof Map) {
+ log.error("The property {} either is not found on node template [{}], or it is data type, or it is not resolved get_input", path, nodeName);
+ return Collections.emptyList();
+ }
+ if (path != null) {
+ return PropertyUtils.findSimplePropertyValueInListOfDataTypes((List<Object>)valueAsObject, path);
+ }
+ return PropertyUtils.buildSimplePropertValueOrList(valueAsObject);
+ }
+
+
+
+
+ private Property getNodeTemplatePropertyObjectByName(NodeTemplate nodeTemplate, String propertyName) {
+ return nodeTemplate.getPropertiesObjects()
+ .stream()
+ .filter(p->p.getName().equals(propertyName))
+ .findFirst()
+ .orElse(null);
+ }
+
+ private NodeTemplate getChildNodeTemplateByName(NodeTemplate parent, String nodeTemplateName) {
+ return getNodeTemplateChildren(parent)
+ .stream()
+ .filter(nt->nt.getName().equals(nodeTemplateName))
+ .findFirst().orElse(null);
+ }
+
+ @Override
public List<Input> getInputsWithAnnotations() {
return toscaTemplate.getInputs(true);
}
public static String PROPERTY_NAME_TARGETS = "targets";
public static String PROPERTY_NAME_MEMBERS = "members";
public static String PROPERTY_NAME_CAPABILITIES = "capabilities";
+ public static String PROPERTY_NAME_ENTRY_SCHEMA = "entry_schema";
}
import org.onap.sdc.tosca.parser.config.ErrorInfo;
import org.onap.sdc.tosca.parser.config.JToscaValidationIssueInfo;
import org.onap.sdc.tosca.parser.config.SdcToscaParserErrors;
+import org.onap.sdc.tosca.parser.enums.JToscaValidationIssueType;
import org.onap.sdc.tosca.parser.utils.GeneralUtility;
import org.onap.sdc.tosca.parser.api.ISdcCsarHelper;
import org.onap.sdc.tosca.parser.exceptions.SdcToscaParserException;
--- /dev/null
+package org.onap.sdc.tosca.parser.utils;
+
+import com.google.common.collect.Lists;
+import org.onap.sdc.tosca.parser.enums.PropertySchemaType;
+import org.onap.sdc.tosca.parser.impl.SdcPropertyNames;
+import org.onap.sdc.toscaparser.api.NodeTemplate;
+import org.onap.sdc.toscaparser.api.Property;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+import static org.onap.sdc.tosca.parser.enums.PropertySchemaType.PropertySchemaComplexity.Simple;
+
+public class PropertyUtils {
+
+ private static Logger log = LoggerFactory.getLogger(PropertyUtils.class.getName());
+
+ private PropertyUtils() {}
+
+ private static String calculatePropertyType(LinkedHashMap<String, Object> property) {
+ String type = (String) property.get(SdcPropertyNames.PROPERTY_NAME_TYPE);
+ if (PropertySchemaType.LIST.getSchemaTypeName().equals(type)) {
+ //it might be a data type
+ return getEntrySchemaType(property);
+ }
+ return type;
+ }
+
+ private static String getEntrySchemaType(LinkedHashMap<String, Object> property) {
+ LinkedHashMap<String, Object> entrySchema = (LinkedHashMap<String, Object>)property.get(SdcPropertyNames.PROPERTY_NAME_ENTRY_SCHEMA);
+ if (entrySchema != null) {
+ return (String) entrySchema.get(SdcPropertyNames.PROPERTY_NAME_TYPE);
+ }
+ return null;
+ }
+
+ private static String calculatePropertyType(Property property) {
+ if (PropertySchemaType.LIST.getSchemaTypeName().equals(property.getType())) {
+ //if it is list, return entry schema type
+ return (String)property.getEntrySchema().get(SdcPropertyNames.PROPERTY_NAME_TYPE);
+ }
+ return property.getType();
+ }
+
+ public static boolean isListOfSimpleTypes(String type) {
+ PropertySchemaType entrySchemaType = PropertySchemaType.getEnumByValue(type);
+ return entrySchemaType.getSchemaTypeComplexity() == PropertySchemaType.PropertySchemaComplexity.Simple;
+ }
+
+ public static boolean isDataPropertyType(String type) {
+ PropertySchemaType entrySchemaType = PropertySchemaType.getEnumByValue(type);
+ return entrySchemaType == PropertySchemaType.DATATYPE;
+ }
+
+ public static Object processProperties(String[] split, LinkedHashMap<String, Property> properties) {
+ Optional<Map.Entry<String, Property>> findFirst = properties.entrySet().stream().filter(x -> x.getKey().equals(split[0])).findFirst();
+ if (findFirst.isPresent()) {
+ Property property = findFirst.get().getValue();
+ Object current = property.getValue();
+ return iterateProcessPath(1, current, split);
+ }
+ String propName = (split != null && split.length > 0 ? split[0] : null);
+ log.error("processProperties - property {} is not found", propName);
+ return null;
+ }
+
+ public static List<String> findSimplePropertyValueInListOfDataTypes(List<Object> valueAsObjectList, String[] path) {
+ return valueAsObjectList.stream()
+ .map(v->iterateProcessPath(1, v, path))
+ .filter(Objects::nonNull)
+ .map(String::valueOf)
+ .collect(Collectors.toList());
+ }
+
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ public static Object iterateProcessPath(Integer index, Object current, String[] split) {
+ if (current == null) {
+ log.error("iterateProcessPath - this input has no default");
+ return null;
+ }
+ if (split.length > index) {
+ for (int i = index; i < split.length; i++) {
+ if (current instanceof Map) {
+ current = ((Map<String, Object>) current).get(split[i]);
+ } else if (current instanceof List) {
+ current = ((List) current).get(0);
+ i--;
+ }
+ else {
+ log.error("iterateProcessPath - found an unexpected leaf where expected to find a complex type");
+ return null;
+ }
+ }
+ }
+ if (current != null) {
+ return current;
+ }
+ log.error("iterateProcessPath - Path not Found");
+ return null;
+ }
+
+ public static boolean isPropertyTypeSimpleOrListOfSimpleTypes(NodeTemplate nodeTemplate, String[] path, Property property) {
+ PropertySchemaType internalPropertyType = PropertyUtils.getPropertyTypeByPath(nodeTemplate, path, property);
+ return internalPropertyType.getSchemaTypeComplexity() == Simple;
+ }
+
+ private static PropertySchemaType getPropertyTypeByPath(NodeTemplate nodeTemplate, String[] path, Property property) {
+ String propertyType = calculatePropertyType(property);
+ String propertyTypeByPath = propertyType;
+
+ if (path.length > 1) {
+ propertyTypeByPath = getInternalPropertyType(nodeTemplate, propertyType, path, 1);
+ }
+ return PropertySchemaType.getEnumByValue(propertyTypeByPath);
+ }
+
+ public static List<String> buildSimplePropertValueOrList(Object value) {
+ if (value instanceof List) {
+ return ((ArrayList<Object>) value)
+ .stream()
+ //it might be null when get_input can't be resolved
+ // e.g.:
+ // - get_input has two parameters: 1. list and 2. index in this list
+ //and list has no value
+ // - neither value no default is defined for get_input
+ .filter(Objects::nonNull)
+ .map(String::valueOf)
+ .collect(Collectors.toList());
+ }
+ return Lists.newArrayList(String.valueOf(value));
+ }
+
+ private static String getInternalPropertyType(NodeTemplate nodeTemplate, String dataTypeName, String[] path, int index) {
+ if (path.length > index) {
+ LinkedHashMap<String, Object> complexProperty = (LinkedHashMap<String, Object>) nodeTemplate.getCustomDef().get(dataTypeName);
+ if (complexProperty != null) {
+ LinkedHashMap<String, Object> properties = (LinkedHashMap<String, Object>) complexProperty.get(SdcPropertyNames.PROPERTY_NAME_PROPERTIES);
+ return getPropertyTypeFromCustomDef(nodeTemplate, path, index, properties);
+ }
+ }
+ //stop searching - seems as wrong flow: the path is finished but the value is not found yet
+ log.error("The property path {} is incorrect, the request will be rejected", path);
+ return null;
+ }
+
+ private static String getPropertyTypeFromCustomDef(NodeTemplate nodeTemplate, String[] path, int index, LinkedHashMap<String, Object> properties) {
+ final String methodName = "getPropertyTypeFromCustomDef";
+ if (properties != null) {
+ LinkedHashMap<String, Object> foundProperty = (LinkedHashMap<String, Object>) (properties).get(path[index]);
+ if (foundProperty != null) {
+ String propertyType = calculatePropertyType(foundProperty);
+ log.info("{} - type {} is data type", methodName, propertyType);
+ if ((index == path.length - 1)){
+ log.info("{} - the last element {} in the property path is found", methodName, path[index]);
+ return propertyType;
+ }
+ return getInternalPropertyType(nodeTemplate, propertyType, path, index + 1);
+ }
+ log.error("{} - the property [{}] is not found", methodName, path[index]);
+ }
+ return null;
+ }
+
+
+}
import com.google.common.collect.ImmutableMap;
import org.apache.commons.lang3.tuple.Pair;
import org.onap.sdc.tosca.parser.exceptions.SdcToscaParserException;
-import org.onap.sdc.tosca.parser.impl.FilterType;
-import org.onap.sdc.tosca.parser.impl.SdcTypes;
+import org.onap.sdc.tosca.parser.enums.FilterType;
+import org.onap.sdc.tosca.parser.enums.SdcTypes;
import org.onap.sdc.toscaparser.api.CapabilityAssignment;
import org.onap.sdc.toscaparser.api.CapabilityAssignments;
import org.onap.sdc.toscaparser.api.Group;
}
//endregion
- //region getNodeTemplatePropertyAsObject
+ //region getNodeTemplatePropertyValueAsObject
@Test
public void testGetNodeTemplatePropertyAsObject() {
List<NodeTemplate> serviceVfList = fdntCsarHelper.getServiceVfList();
- assertEquals("2", fdntCsarHelper.getNodeTemplatePropertyAsObject(serviceVfList.get(0), "availability_zone_max_count"));
- assertEquals(3, fdntCsarHelper.getNodeTemplatePropertyAsObject(serviceVfList.get(0), "max_instances"));
- assertEquals("some code", fdntCsarHelper.getNodeTemplatePropertyAsObject(serviceVfList.get(0), "nf_naming_code"));
+ assertEquals("2", fdntCsarHelper.getNodeTemplatePropertyValueAsObject(serviceVfList.get(0), "availability_zone_max_count"));
+ assertEquals(3, fdntCsarHelper.getNodeTemplatePropertyValueAsObject(serviceVfList.get(0), "max_instances"));
+ assertEquals("some code", fdntCsarHelper.getNodeTemplatePropertyValueAsObject(serviceVfList.get(0), "nf_naming_code"));
}
//endregion
// 2) complex type resolving
// 3) List access resolving
List<NodeTemplate> vfcs = resolveGetInputCsar.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
- Object propertyAsObject = resolveGetInputCsar.getNodeTemplatePropertyAsObject(vfcs.get(0), "port_pd01_port_ip_requirements");
+ Object propertyAsObject = resolveGetInputCsar.getNodeTemplatePropertyValueAsObject(vfcs.get(0), "port_pd01_port_ip_requirements");
assertTrue(propertyAsObject instanceof ArrayList);
assertEquals(2, ((ArrayList) propertyAsObject).size());
//port_pd01_port_ip_requirements:
public void testResolveGetInputForPrimitiveTypeString() {
//This test covers "default" resolving of primitive - as Object
List<NodeTemplate> vfcs = resolveGetInputCsar.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
- Object propertyAsObject = resolveGetInputCsar.getNodeTemplatePropertyAsObject(vfcs.get(0), "port_pd01_port_network_role_tag");
+ Object propertyAsObject = resolveGetInputCsar.getNodeTemplatePropertyValueAsObject(vfcs.get(0), "port_pd01_port_network_role_tag");
assertEquals("oam", propertyAsObject);
}
public void testResolveGetInputForMap() {
//This test covers "default" resolving of primitive - as Map
List<NodeTemplate> vfcs = resolveGetInputCsar.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
- Object propertyAsObject = resolveGetInputCsar.getNodeTemplatePropertyAsObject(vfcs.get(0), "port_pd02_port_ip_requirements#ip_count_required");
+ Object propertyAsObject = resolveGetInputCsar.getNodeTemplatePropertyValueAsObject(vfcs.get(0), "port_pd02_port_ip_requirements#ip_count_required");
assertTrue(propertyAsObject instanceof Map);
assertEquals(false, ((Map)propertyAsObject).get("is_required"));
}
public void testResolveGetInputForAllHierarchy() {
//This test covers "default" resolving from service level
List<NodeTemplate> vfs = resolveGetInputCsar.getServiceVfList();
- Object vfPropertyAsObject = resolveGetInputCsar.getNodeTemplatePropertyAsObject(vfs.get(0), "vm_count");
+ Object vfPropertyAsObject = resolveGetInputCsar.getNodeTemplatePropertyValueAsObject(vfs.get(0), "vm_count");
assertEquals(2, vfPropertyAsObject);
//This test covers property assignment resolving on VFI level (service template), from Vf level
List<NodeTemplate> vfcs = resolveGetInputCsar.getNodeTemplateBySdcType(vfs.get(0), SdcTypes.VFC);
- Object vfcPropertyAsObject = resolveGetInputCsar.getNodeTemplatePropertyAsObject(vfcs.get(0), "my_count");
+ Object vfcPropertyAsObject = resolveGetInputCsar.getNodeTemplatePropertyValueAsObject(vfcs.get(0), "my_count");
assertEquals(2, vfcPropertyAsObject); //takes it from upper level (VF) property
}
public void testResolveGetInputNoDefValueServiceLevel() {
//This test covers resolving when no "default" value is supplied to the input - should be null - Service/VFI level
List<NodeTemplate> vfs = resolveGetInputCsar.getServiceVfList();
- Object vfPropertyAsObject = resolveGetInputCsar.getNodeTemplatePropertyAsObject(vfs.get(0), "port_order");
+ Object vfPropertyAsObject = resolveGetInputCsar.getNodeTemplatePropertyValueAsObject(vfs.get(0), "port_order");
assertNull(vfPropertyAsObject);
}
public void testResolveGetInputForComplexTypeAndListWithFalseValue()
{
List<NodeTemplate> vfcs = resolveGetInputCsarFalse.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
- Object propertyAsObject = resolveGetInputCsarFalse.getNodeTemplatePropertyAsObject(vfcs.get(0), "port_pd01_port_ip_requirements");
+ Object propertyAsObject = resolveGetInputCsarFalse.getNodeTemplatePropertyValueAsObject(vfcs.get(0), "port_pd01_port_ip_requirements");
assertTrue(propertyAsObject instanceof ArrayList);
assertEquals(2, ((ArrayList) propertyAsObject).size());
assertEquals("get_input:[ip_requirements, 0]", ((ArrayList) propertyAsObject).get(0).toString());
@Test
public void testResolveGetInputForPrimitiveTypeStringWithFalseValue() {
List<NodeTemplate> vfcs = resolveGetInputCsarFalse.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
- Object propertyAsObject = resolveGetInputCsarFalse.getNodeTemplatePropertyAsObject(vfcs.get(0), "port_pd01_port_network_role_tag");
+ Object propertyAsObject = resolveGetInputCsarFalse.getNodeTemplatePropertyValueAsObject(vfcs.get(0), "port_pd01_port_network_role_tag");
assertEquals("get_input:role_tag_oam", propertyAsObject.toString());
}
@Test
public void testResolveGetInputForPrimitiveTypeListWithFalseValue() {
List<NodeTemplate> vfcs = resolveGetInputCsarFalse.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
- Object propertyAsObject = resolveGetInputCsarFalse.getNodeTemplatePropertyAsObject(vfcs.get(0), "compute_pd_server_name");
+ Object propertyAsObject = resolveGetInputCsarFalse.getNodeTemplatePropertyValueAsObject(vfcs.get(0), "compute_pd_server_name");
assertEquals("[get_input:[pd_server_names, 0]]", propertyAsObject.toString());
}
//@Test // Maybe a bug here.... need to check with Esti - Mait was sent.
public void testResolveGetInputForPrimitiveTypeList() {
List<NodeTemplate> vfcs = resolveGetInputCsar.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
- Object propertyAsObject = resolveGetInputCsar.getNodeTemplatePropertyAsObject(vfcs.get(0), "compute_pd_server_name");
+ Object propertyAsObject = resolveGetInputCsar.getNodeTemplatePropertyValueAsObject(vfcs.get(0), "compute_pd_server_name");
assertEquals("\"ZRDM1MOGX01MPD001\"", propertyAsObject.toString());
}
public void testResolveGetInputForPrimitiveNullValue() {
List<NodeTemplate> vfcs = resolveGetInputCsarQA.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
@SuppressWarnings("unchecked")
- List<String>propertyAsObject = (List<String>) resolveGetInputCsarQA.getNodeTemplatePropertyAsObject(vfcs.get(0), "compute_pd_server_availability_zone");
+ List<String>propertyAsObject = (List<String>) resolveGetInputCsarQA.getNodeTemplatePropertyValueAsObject(vfcs.get(0), "compute_pd_server_availability_zone");
assertNull(propertyAsObject.get(0));
}
@Test
public void testResolveGetInputForPrimitiveIPValue() {
List<NodeTemplate> vfcs = resolveGetInputCsarQA.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
- Object propertyAsObject = resolveGetInputCsarQA.getNodeTemplatePropertyAsObject(vfcs.get(0), "vm_image_name");
+ Object propertyAsObject = resolveGetInputCsarQA.getNodeTemplatePropertyValueAsObject(vfcs.get(0), "vm_image_name");
assertEquals("107.239.36.5", propertyAsObject.toString());
}
@Test
public void testResolveGetInputArrayStructure() {
List<NodeTemplate> vfcs = resolveGetInputCsarQA.getVfcListByVf("b5190df2-7880-4d6f-836f-56ab17e1b85b");
- Object propertyAsObject = resolveGetInputCsarQA.getNodeTemplatePropertyAsObject(vfcs.get(0), "compute_pd_server_name");
+ Object propertyAsObject = resolveGetInputCsarQA.getNodeTemplatePropertyValueAsObject(vfcs.get(0), "compute_pd_server_name");
assertEquals( ((ArrayList)propertyAsObject).get(0).toString(), "\"ZRDM1MOGX01MPD001\"");
- propertyAsObject = resolveGetInputCsarQA.getNodeTemplatePropertyAsObject(vfcs.get(0), "port_pd01_port_ip_requirements");
- assertEquals( ((ArrayList)propertyAsObject).get(1), null);
+ propertyAsObject = resolveGetInputCsarQA.getNodeTemplatePropertyValueAsObject(vfcs.get(0), "port_pd01_port_ip_requirements");
+ assertEquals(2, ((ArrayList)propertyAsObject).size());
}
@Test
assertNotNull(inputs);
validateInputsAnnotations(inputs);
}
-
+
+ @Test
+ public void getPropertyValueByNamePathAndNodeTypePathWhenPropertyValueIncludesGetInputAndPropertyHasDataType() {
+ List<String> propertyValues = csarHelperServiceGroupsInputs.getPropertyLeafValueByPropertyNamePathAndNodeTemplatePath("exCP_naming",
+ "vDBE 0#abstract_vdbe_1#vdbe_vdbe_untr_port");
+ assertEquals(0, propertyValues.size());
+ }
+
+ @Test
+ public void getPropertyValueByNamePathAndNodeTypePathWhenPropertyPathIsComplex() {
+ List<String> propertyValues = csarHelperServiceGroupsInputs.getPropertyLeafValueByPropertyNamePathAndNodeTemplatePath("exCP_naming#ecomp_generated_naming",
+ "vDBE 0#abstract_vdbe_1#vdbe_vdbe_untr_port");
+ assertEquals(1, propertyValues.size());
+ assertEquals("true", propertyValues.get(0));
+ }
+
+ @Test
+ public void getPropertyValueByNamePathAndNodeTypePathWhenNoValueFoundForGetInputProperty() {
+ List<String> propertyValues = csarHelperServiceGroupsInputs.getPropertyLeafValueByPropertyNamePathAndNodeTemplatePath("virtual_machine_interface_allowed_address_pairs#allowed_address_pair#address_mode",
+ "vDBE 0#abstract_vdbe_1#vdbe_vdbe_untr_port_nested2#vdbe_0_subint_oam_vmi_0");
+ assertEquals(0, propertyValues.size());
+ }
+
+ @Test
+ public void getPropertyValueByNamePathAndNodeTemplatePathSuccess() {
+ List<String> propertyValues = csarHelperServiceGroupsInputs.getPropertyLeafValueByPropertyNamePathAndNodeTemplatePath("is_default",
+ "vDBE 0#abstract_vdbe_1#vdbe_vdbe_untr_port_nested2#vdbe_0_subint_oam_vmi_0");
+ assertEquals(1, propertyValues.size());
+ assertEquals("false", propertyValues.get(0));
+ }
+
+ @Test
+ public void getPropertyValueByNamePathAndEmptyNodeTypePath() {
+ List<String> propertyValues = csarHelperServiceGroupsInputs.getPropertyLeafValueByPropertyNamePathAndNodeTemplatePath(null, "");
+ assertEquals(0, propertyValues.size());
+ }
+
+ @Test
+ public void getPropertyValueByNamePathAndNullNodeTypePath() {
+ List<String> propertyValues = csarHelperServiceGroupsInputs.getPropertyLeafValueByPropertyNamePathAndNodeTemplatePath(null, null);
+ assertTrue(propertyValues.isEmpty());
+ }
+
+ @Test
+ public void getPropertyValueByNamePathAndNodeTypePathForListOfGetInputs() {
+ List<String> propertyValues = resolveGetInputCsar.getPropertyLeafValueByPropertyNamePathAndNodeTemplatePath("port_pd01_port_ip_requirements#subnet_role",
+ "ipAssign4 0#abstract_pd_server");
+ assertEquals(2, propertyValues.size());
+ assertTrue(propertyValues.get(0).equals("subnet_role_4") || propertyValues.get(0).equals("subnet_role_6"));
+ assertTrue(propertyValues.get(1).equals("subnet_role_4") || propertyValues.get(1).equals("subnet_role_6"));
+ }
+
+ @Test
+ public void getPropertyValueByNamePathAndNodeTypePathForNetworkCloud() {
+ List<String> propertyValues = csarHelperServiceNetworkCloud.getPropertyLeafValueByPropertyNamePathAndNodeTemplatePath("related_networks#related_network_role",
+ "Network Cloud VNF MOCK 0#abstract_testVM#testVM_testVM_SRIOVtrunk1_port");
+ assertEquals(3, propertyValues.size());
+ assertTrue(propertyValues.contains("cor_direct_2"));
+ assertTrue(propertyValues.contains("sgi_direct_2"));
+ assertTrue(propertyValues.contains("int_imbl_2"));
+ }
+
+ @Test
+ public void getPropertyValueByNamePathAndSingleNodeTypeNameForNetworkCloud() {
+ List<String> propertyValues = csarHelperServiceNetworkCloud.getPropertyLeafValueByPropertyNamePathAndNodeTemplatePath("nf_naming#ecomp_generated_naming",
+ "Network Cloud VNF MOCK 0");
+ assertEquals(1, propertyValues.size());
+ assertEquals("true", propertyValues.get(0));
+ }
+
+ @Test
+ //todo test for port_order on resolveGetInputCsar
+ public void getPropertyValueByNamePathAndNodeTypePathWithGetInputNotSet() {
+ List<String> propertyValues = csarHelperServiceNetworkCloud.getPropertyLeafValueByPropertyNamePathAndNodeTemplatePath(
+ "name", "Network Cloud VNF MOCK 0#abstract_testVM#testVM");
+ assertTrue(propertyValues.isEmpty());
+ }
+
+
@SuppressWarnings("unchecked")
private void validateInputsProperties(NodeTemplate vdbe0, Group group) {
assertNotNull(group.getPropertiesObjects());
package org.onap.sdc.impl;
-import org.onap.sdc.tosca.parser.impl.SdcTypes;
+import org.onap.sdc.tosca.parser.enums.SdcTypes;
import org.onap.sdc.toscaparser.api.CapabilityAssignments;
import org.onap.sdc.toscaparser.api.CapabilityAssignment;
import org.onap.sdc.toscaparser.api.NodeTemplate;
import org.onap.sdc.toscaparser.api.RequirementAssignments;
-import org.onap.sdc.toscaparser.api.elements.Metadata;
import org.testng.annotations.Test;
import java.util.List;
--- /dev/null
+package org.onap.sdc.tosca.parser.impl;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.onap.sdc.tosca.parser.api.ISdcCsarHelper;
+import org.onap.sdc.tosca.parser.enums.PropertySchemaType;
+import org.onap.sdc.tosca.parser.utils.PropertyUtils;
+import org.onap.sdc.toscaparser.api.NodeTemplate;
+import org.onap.sdc.toscaparser.api.Property;
+import org.onap.sdc.toscaparser.api.ToscaTemplate;
+import org.onap.sdc.toscaparser.api.elements.Metadata;
+
+import java.util.LinkedHashMap;
+import java.util.NoSuchElementException;
+
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.when;
+import static org.testng.Assert.assertFalse;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ToscaParserNodeTemplateMockTest {
+ @Mock
+ private NodeTemplate nodeTemplate;
+
+ @Mock
+ private Metadata metadata;
+
+ @Mock
+ private ToscaTemplate toscaTemplate;
+
+ @Mock
+ private Property property;
+
+ private static final String dataTypeA = String.format(".%s.aaa", PropertySchemaType.DATATYPE.getSchemaTypeName());
+ private static final String dataTypeB = String.format(".%s.bbb", PropertySchemaType.DATATYPE.getSchemaTypeName());
+ private static final String dataTypeD = String.format(".%s.ddd", PropertySchemaType.DATATYPE.getSchemaTypeName());
+ private static final String dataTypeR = String.format(".%s.rrr", PropertySchemaType.DATATYPE.getSchemaTypeName());
+
+ @Before
+ public void setUp() {
+ when(property.getType()).thenReturn(dataTypeA);
+ }
+
+
+ @Test
+ public void verifyCorrectPropertyPath() {
+ String[] path = String.format("%s#%s#%s#%s", "x", "y", "z", "q").split("#");
+ LinkedHashMap<String, Object> bProp = fillDataTypeEntry(dataTypeA, "y", dataTypeB);
+ LinkedHashMap<String, Object> cProp = fillDataTypeEntry(dataTypeB, "z", dataTypeD);
+ LinkedHashMap<String, Object> dProp = fillDataTypeEntry(dataTypeD, "q", PropertySchemaType.STRING.getSchemaTypeName());
+
+ when(nodeTemplate.getCustomDef())
+ .thenReturn(bProp)
+ .thenReturn(cProp)
+ .thenReturn(dProp);
+
+ assertTrue(PropertyUtils.isPropertyTypeSimpleOrListOfSimpleTypes(nodeTemplate, path, property));
+ }
+
+ @Test
+ public void verifyPropertyPathWithMapOfStringsType() {
+ String[] path = String.format("%s#%s#%s#%s", "x", "y", "z", "q").split("#");
+ LinkedHashMap<String, Object> bProp = fillDataTypeEntry(dataTypeA, "y", dataTypeB);
+ LinkedHashMap<String, Object> cProp = fillDataTypeEntry(dataTypeB, "z", PropertySchemaType.MAP.getSchemaTypeName());
+ LinkedHashMap<String, Object> dProp = fillDataTypeEntry(PropertySchemaType.MAP.getSchemaTypeName(), "q", PropertySchemaType.STRING.getSchemaTypeName());
+
+ when(nodeTemplate.getCustomDef())
+ .thenReturn(bProp)
+ .thenReturn(cProp)
+ .thenReturn(dProp);
+
+ assertTrue(PropertyUtils.isPropertyTypeSimpleOrListOfSimpleTypes(nodeTemplate, path, property));
+ }
+
+ @Test
+ public void verifyPropertyPathWithMapType() {
+ String[] path = String.format("%s#%s#%s", "x", "y", "z").split("#");
+ LinkedHashMap<String, Object> bProp = fillDataTypeEntry(dataTypeA, "y", dataTypeB);
+ LinkedHashMap<String, Object> cProp = fillDataTypeEntry(dataTypeB, "z", PropertySchemaType.MAP.getSchemaTypeName());
+
+ when(nodeTemplate.getCustomDef())
+ .thenReturn(bProp)
+ .thenReturn(cProp);
+
+ assertFalse(PropertyUtils.isPropertyTypeSimpleOrListOfSimpleTypes(nodeTemplate, path, property));
+ }
+
+
+ @Test
+ public void verifyPropertyPathWithListOfDataTypeShouldBeRejected() {
+ String[] path = String.format("%s#%s#%s#%s", "x", "y", "z", "m").split("#");
+ LinkedHashMap<String, Object> bProp = fillDataTypeEntry(dataTypeA, "y", dataTypeB);
+ LinkedHashMap<String, Object> cProp = fillDataTypeEntry(dataTypeB, "z", dataTypeD);
+ LinkedHashMap<String, Object> dProp = fillDataTypeEntry(dataTypeD, "m", PropertySchemaType.LIST.getSchemaTypeName(), dataTypeR);
+
+ when(nodeTemplate.getCustomDef())
+ .thenReturn(bProp)
+ .thenReturn(cProp)
+ .thenReturn(dProp);
+
+ assertFalse(PropertyUtils.isPropertyTypeSimpleOrListOfSimpleTypes(nodeTemplate, path, property));
+ }
+
+ @Test
+ public void verifyPropertyPathWithListOfIntegersAsType() {
+ String[] path = String.format("%s#%s#%s#%s", "x", "y", "z", "m").split("#");
+ LinkedHashMap<String, Object> bProp = fillDataTypeEntry(dataTypeA, "y", dataTypeB);
+ LinkedHashMap<String, Object> cProp = fillDataTypeEntry(dataTypeB, "z", dataTypeD);
+ LinkedHashMap<String, Object> dProp = fillDataTypeEntry(dataTypeD, "m", PropertySchemaType.LIST.getSchemaTypeName(), PropertySchemaType.INTEGER.getSchemaTypeName());
+
+ when(nodeTemplate.getCustomDef())
+ .thenReturn(bProp)
+ .thenReturn(cProp)
+ .thenReturn(dProp);
+
+ assertTrue(PropertyUtils.isPropertyTypeSimpleOrListOfSimpleTypes(nodeTemplate, path, property));
+ }
+
+ @Test
+ public void propertyPathIsRejectedAsShorterThanExpected() {
+ String[] path = String.format("%s#%s", "x", "y").split("#");
+ LinkedHashMap<String, Object> bProp = fillDataTypeEntry(dataTypeA, "y", dataTypeB);
+ LinkedHashMap<String, Object> dProp = fillDataTypeEntry(dataTypeB, "z", PropertySchemaType.STRING.getSchemaTypeName());
+
+ when(nodeTemplate.getCustomDef())
+ .thenReturn(bProp)
+ .thenReturn(dProp);
+
+ assertFalse(PropertyUtils.isPropertyTypeSimpleOrListOfSimpleTypes(nodeTemplate, path, property));
+ }
+
+ @Test(expected = NoSuchElementException.class)
+ public void propertyPathIsRejectedAsLongerThanExpected() {
+ String[] path = String.format("%s#%s#%s#%s", "x", "y", "z", "q").split("#");
+ LinkedHashMap<String, Object> bProp = fillDataTypeEntry(dataTypeA, "y", dataTypeB);
+ LinkedHashMap<String, Object> dProp = fillDataTypeEntry(dataTypeB, "z", PropertySchemaType.STRING.getSchemaTypeName());
+
+ when(nodeTemplate.getCustomDef())
+ .thenReturn(bProp)
+ .thenReturn(dProp);
+
+ PropertyUtils.isPropertyTypeSimpleOrListOfSimpleTypes(nodeTemplate, path, property);
+ }
+
+ @Test(expected = NoSuchElementException.class)
+ public void propertyPathIsRejectedAsPropertyIsNotFound() {
+ String[] path = String.format("%s#%s", "x", "y").split("#");
+ LinkedHashMap<String, Object> bProp = fillDataTypeEntry(dataTypeA, "t", dataTypeB);
+ when(nodeTemplate.getCustomDef())
+ .thenReturn(bProp);
+
+ assertFalse(PropertyUtils.isPropertyTypeSimpleOrListOfSimpleTypes(nodeTemplate, path, property));
+ }
+
+ @Test
+ public void verifyNodeTypeIsNotSupported() {
+ when(nodeTemplate.getMetaData()).thenReturn(metadata);
+ when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)).thenReturn("VFC-TEST");
+
+ ISdcCsarHelper sdcCsarHelper = new SdcCsarHelperImpl(toscaTemplate);
+ assertFalse(sdcCsarHelper.isNodeTypeSupported(nodeTemplate));
+ }
+
+
+ private LinkedHashMap<String, Object> fillDataTypeEntry(String dataTypeName, String propertyName, String type) {
+ return fillDataTypeEntry(dataTypeName, propertyName, type, "");
+ }
+
+ private LinkedHashMap<String, Object> fillDataTypeEntry(String dataTypeName, String propertyName, String type, String entrySchemaType) {
+ LinkedHashMap<String, Object> dataTypes = new LinkedHashMap<>();
+ LinkedHashMap<String, Object> properties = new LinkedHashMap<>();
+ LinkedHashMap<String, Object> property = new LinkedHashMap<>();
+ LinkedHashMap<String, Object> dataType = new LinkedHashMap<>();
+ property.put(SdcPropertyNames.PROPERTY_NAME_TYPE, type);
+ property.put(SdcPropertyNames.PROPERTY_NAME_NAME, propertyName);
+
+ PropertySchemaType propertySchemaType = PropertySchemaType.getEnumByValue(type);
+
+ if (!StringUtils.isEmpty(entrySchemaType) &&
+ (propertySchemaType.getSchemaTypeComplexity() == PropertySchemaType.PropertySchemaComplexity.Complex)) {
+ LinkedHashMap<String, Object> entry_schema = new LinkedHashMap<>();
+ entry_schema.put(SdcPropertyNames.PROPERTY_NAME_TYPE, entrySchemaType);
+ property.put(SdcPropertyNames.PROPERTY_NAME_ENTRY_SCHEMA, entry_schema);
+ }
+ properties.put(propertyName, property);
+ dataType.put(SdcPropertyNames.PROPERTY_NAME_PROPERTIES, properties);
+ dataTypes.put(dataTypeName, dataType);
+ return dataTypes;
+ }
+
+
+
+}
major=1
minor=4
-patch=4
+patch=5
base_version=${major}.${minor}.${patch}
Code Review / sdc / sdc-tosca.git / commitdiff