## 1.4.7
### Bug fix:
-1. **validation fix** Null value caused to NullPointerException in validate function in DataEntity
\ No newline at end of file
+1. **validation fix** Null value caused to NullPointerException in validate function in DataEntity
+
+
+## 1.4.8
+
+### Features:
+1. A new API is declared:
+
+*List<IEntityDetails> getEntity(EntityQuery entityQuery, TopologyTemplateQuery topologyTemplateQuery, boolean isRecursive)*
+
+It is designed to retrieve details of one or more entity templates from corresponding topology template according to provided query parameters
+
+2. Mock-up version of **getEntity** API is implemented.
+
+### Note:
+This version is intended for SDN-C team usage only.
<artifactId>sdc-tosca</artifactId>
<name>sdc-sdc-tosca</name>
<description>SDC Tosca Parser JAR file for use by consumers</description>
- <version>1.4.9-SNAPSHOT</version>
+ <version>1.4.10-SNAPSHOT</version>
<packaging>jar</packaging>
<properties>
<dependency>
<groupId>org.onap.sdc.jtosca</groupId>
<artifactId>jtosca</artifactId>
- <version>1.4.9</version>
+ <version>1.4.10-SNAPSHOT</version>
</dependency>
package org.onap.sdc.tosca.parser.api;
import org.onap.sdc.tosca.parser.enums.EntityTemplateType;
+import org.onap.sdc.toscaparser.api.CapabilityAssignment;
import org.onap.sdc.toscaparser.api.Property;
+import org.onap.sdc.toscaparser.api.RequirementAssignment;
import org.onap.sdc.toscaparser.api.elements.Metadata;
import java.util.List;
import java.util.Map;
public interface IEntityDetails {
+ /**
+ * Retrieves entity instance template type.
+ * @return {@link EntityTemplateType} enum entry describing given object type
+ */
EntityTemplateType getType();
+
+ /**
+ * Retrieves entity instance name
+ */
String getName();
+
+ /**
+ * Retrieves entity {@link Metadata} object
+ */
Metadata getMetadata();
+
+ /**
+ * Retrieves entity instance properties
+ * @return map of entity property names and corresponding {@link Property} object instances
+ */
Map<String, Property> getProperties();
- List<Property> getPropertyList();
+
+ /**
+ * Retrieves member nodes of the entity instance
+ * @return List of member nodes entity objects
+ */
List<IEntityDetails> getMemberNodes();
+
+ /**
+ * Retrieves node template containing the current entity instance.
+ * @return parent entity instance or null if the entity is contained by service
+ */
IEntityDetails getParent();
+
+ /**
+ * Retrieves path to the searched entity instance in the model. It is based on the collection of the node templates names delimited by #.
+ * The entity instance may exist in the service node templates, in the VF node templates or in the nested of nested CVFC.
+ * The path will include the VF name, then the names of the CVFC recursively.
+ * If the entity instance is located in the service directly, the path is empty string
+ */
String getPath();
-}
+ /**
+ * Retrieves map of requirements of the entity instance
+ * @return map of entity requirement names and corresponding {@link RequirementAssignment} object instances
+ */
+ Map<String, RequirementAssignment> getRequirements();
+
+ /**
+ * Retrieves map of capabilities of the entity instance
+ * @return map of entity capability names and corresponding {@link CapabilityAssignment} object instances
+ */
+ Map<String, CapabilityAssignment> getCapabilities();
+
+ /**
+ * Retrieves list of policy target names
+ */
+ List<String> getTargets();
+
+ /**
+ * Retrieves list of policy target entity instances (groups or node templates)
+ */
+ List<IEntityDetails> getTargetNodes();
+}
\ No newline at end of file
* @param nodeType - the TOSCA type of the node.
* @return service node templates of this type.
*/
+ @Deprecated
public List<NodeTemplate> getServiceNodeTemplatesByType(String nodeType);
/**
*
* @return service node templates.
*/
+ @Deprecated
public List<NodeTemplate> getServiceNodeTemplates();
/**
* @param vfCustomizationUuid - customizationUuid of VF instance.
* @return list of vfModule groups.
*/
+ @Deprecated
public List<Group> getVfModulesByVf(String vfCustomizationUuid);
* @param pathToPropertyLeafValue - the full path of the required property.
* @return the leaf value as String, or null if there's no such property, or it's not a leaf.
*/
+ @Deprecated
public String getNodeTemplatePropertyLeafValue(NodeTemplate nodeTemplate, String pathToPropertyLeafValue);
/**
* @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.
*/
+ @Deprecated
public Object getNodeTemplatePropertyValueAsObject(NodeTemplate nodeTemplate, String pathToPropertyLeafValue);
/**
* @param propertyName - the name of the required property.
* @return the leaf value as String, or null if there's no such property, or it's not a leaf.
*/
+ @Deprecated
public String getGroupPropertyLeafValue(Group group, String propertyName);
/**
* @param propertyName - the name 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.
*/
+ @Deprecated
public Object getGroupPropertyAsObject(Group group, String propertyName);
/**
* Get all VL node templates of the CSAR service.
* @return - all VL node templates.
*/
+ @Deprecated
public List<NodeTemplate> getServiceVlList();
/**
* Get all VF node templates of the CSAR service.
* @return - all VF node templates.
*/
+ @Deprecated
public List<NodeTemplate> getServiceVfList();
* @param metadataPropertyName - the name of the metadata property.
* @return metadata property value
*/
+ @Deprecated
public String getMetadataPropertyValue(Metadata metadata, String metadataPropertyName);
* @param vfCustomizationId - customizationUuid of the VF node template.
* @return all VFC node templates from a specified VF
*/
+ @Deprecated
public List<NodeTemplate> getVfcListByVf(String vfCustomizationId);
/**
* @param vfCustomizationId - customizationUuid of the VF node template.
* @return all CP node templates from a specified VF
*/
+ @Deprecated
public List<NodeTemplate> getCpListByVf(String vfCustomizationId);
/**
* @return node templates from vf with the names as in members section.
*
*/
+ @Deprecated
public List<NodeTemplate> getMembersOfVfModule(NodeTemplate vf, Group vfModule);
* Get all allotted node templates from this service.
* @return all allotted node templates from this service.
*/
+ @Deprecated
public List<NodeTemplate> getAllottedResources();
/**
* @param nodeTemplate - node template object
* @return - node type string.
*/
+ @Deprecated
public String getTypeOfNodeTemplate(NodeTemplate nodeTemplate);
/**
* @param vfc - VFC node template to look for CP-related props.
* @return map <b>CP node template name</b> to a map of <b>property name</b> - <b> property value as object</b>.
*/
+ @Deprecated
public Map<String, Map<String, Object>> getCpPropertiesFromVfcAsObject(NodeTemplate vfc);
/**
* @param nt - node template
* @return customization UUID of a node template.
*/
+ @Deprecated
public String getNodeTemplateCustomizationUuid(NodeTemplate nt);
/**
* @param sdcType - the SDC type of the node.
* @return node templates of this SDC type.
*/
+ @Deprecated
public List<NodeTemplate> getNodeTemplateBySdcType(NodeTemplate parentNodeTemplate, SdcTypes sdcType);
/**
* @param sdcType - the SDC type of the node (for example, CP, VF...).
* @return service node templates of this SDC type.
*/
+ @Deprecated
public List<NodeTemplate> getServiceNodeTemplateBySdcType(SdcTypes sdcType);
/**
* @param vfCustomizationUuid - the Customization UUID of the node.
* @return VNF Configuration Node Template.
*/
+ @Deprecated
public NodeTemplate getVnfConfig(String vfCustomizationUuid);
/**
* @param nodeTemplate - Node Template to check
* @return true if node template has topology template, false if not.
*/
+ @Deprecated
public boolean hasTopology(NodeTemplate nodeTemplate);
/**
* @param nodeTemplate - Node Template to get its children
* @return return list of children node templates for node template.
*/
+ @Deprecated
public List<NodeTemplate> getNodeTemplateChildren(NodeTemplate nodeTemplate);
/**
* @param nodeName - the name of the node template.
* @return service-level node template with this name, or null if no such node template was found.
*/
+ @Deprecated
public NodeTemplate getServiceNodeTemplateByNodeName(String nodeName);
/**
* @param nt - Node template to get its Metadata object.
* @return Metadata for this node template, or null if not found.
*/
+ @Deprecated
public Metadata getNodeTemplateMetadata(NodeTemplate nt);
/**
* @return CapabilitiesAssignments that contains list of capability assignments for the node template.<br>
* If none found, an empty list will be returned.
*/
+ @Deprecated
public CapabilityAssignments getCapabilitiesOf(NodeTemplate nt);
/**
* @return RequirementAssignments that contains list of requirement assignments for the node template.
* If none found, an empty list will be returned.
*/
+ @Deprecated
public RequirementAssignments getRequirementsOf(NodeTemplate nt);
/**
* @param pathToPropertyLeafValue - the full path of the required property.
* @return the leaf value as String, or null if there's no such property, or it's not a leaf.
*/
+ @Deprecated
public String getCapabilityPropertyLeafValue(CapabilityAssignment capability, String pathToPropertyLeafValue);
/**
* Get all the policies of the main topology template (either VF or service)
* @return the list of the policies
*/
+ @Deprecated
public List<Policy> getPoliciesOfTopologyTemplate();
/**
* @param policyTypeName the name of the policy type
* @return the list of the policies
*/
+ @Deprecated
public List<Policy> getPoliciesOfTopologyTemplateByToscaPolicyType(String policyTypeName);
/**
* @param nodeTemplate the node template
* @return the list of the policies
*/
+ @Deprecated
public List<Policy> getPoliciesOfOriginOfNodeTemplate(NodeTemplate nodeTemplate);
/**
* @param policyTypeName the name of the policy type
* @return the list of the policies
*/
+ @Deprecated
List<Policy> getPoliciesOfOriginOfNodeTemplateByToscaPolicyType(NodeTemplate nodeTemplate, String policyTypeName);
/**
* @param policyName the name of the policy
* @return the list of the node templates
*/
+ @Deprecated
List<NodeTemplate> getPolicyTargetsFromTopologyTemplate(String policyName);
/**
* @param policyName the name of the policy
* @return the list of the node templates
*/
+ @Deprecated
List<NodeTemplate> getPolicyTargetsFromOrigin(NodeTemplate nodeTemplate, String policyName);
/**
* @param nodeTemplateName the name of the node template
* @return the node template
*/
+ @Deprecated
NodeTemplate getNodeTemplateByName(String nodeTemplateName);
/**
* @param targetNode the node template
* @return the list of the policies
*/
+ @Deprecated
List<Policy> getPoliciesOfTarget(NodeTemplate targetNode);
/**
* @param policyTypeName the name of the policy type
* @return the list of the policies
*/
+ @Deprecated
List<Policy> getPoliciesOfTargetByToscaPolicyType(NodeTemplate nodeTemplate, String policyTypeName);
/**
* @param nodeTemplate the node template
* @return the list of the groups
*/
+ @Deprecated
ArrayList<Group> getGroupsOfOriginOfNodeTemplate(NodeTemplate nodeTemplate);
/**
* @param groupType the group type
* @return the list of the groups
*/
+ @Deprecated
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
*/
+ @Deprecated
ArrayList<Group> getGroupsOfTopologyTemplate();
/**
* @param groupType the group type
* @return the list of the groups
*/
+ @Deprecated
ArrayList<Group> getGroupsOfOriginOfNodeTemplateByToscaGroupType(NodeTemplate nodeTemplate, String groupType);
/**
* @param groupName the name of the group
* @return the list of the node templates
*/
+ @Deprecated
List<NodeTemplate> getGroupMembersFromTopologyTemplate(String groupName);
/**
* @param groupName the name of the group
* @return the list of the node templates
*/
+ @Deprecated
List<NodeTemplate> getGroupMembersOfOriginOfNodeTemplate(NodeTemplate nodeTemplate, String groupName);
/**
* 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.
*/
+ @Deprecated
List<String> getPropertyLeafValueByPropertyNamePathAndNodeTemplatePath(String propertyNamePath, String nodeTemplatePath);
boolean isNodeTypeSupported(NodeTemplate nodeTemplate);
* SDC (node template) type, tosca type as well as optional customizationUUID and UUID
* @param topologyTemplateQuery parameters of the topology template containing the above entity.
* Includes SDC type of the container and optional customizationUUID
- * @param isRecursive indicates if the search is recursive or not
+ * @param isRecursive indicates if the search within the required topology template is recursive.
* @return list of @{@link IEntityDetails} objects containing information about the found entities.
* If either no entities found or the provided query is incorrect, an empty list is returned
*/
import org.onap.sdc.tosca.parser.api.IEntityDetails;
import org.onap.sdc.tosca.parser.enums.EntityTemplateType;
+import org.onap.sdc.toscaparser.api.CapabilityAssignment;
import org.onap.sdc.toscaparser.api.EntityTemplate;
-import org.onap.sdc.toscaparser.api.NodeTemplate;
import org.onap.sdc.toscaparser.api.Property;
+import org.onap.sdc.toscaparser.api.RequirementAssignment;
-import java.util.ArrayList;
+import java.util.Collections;
import java.util.List;
import java.util.Map;
+import java.util.stream.Collectors;
public abstract class EntityDetails implements IEntityDetails {
private final EntityTemplate entityTemplate;
+ private final IEntityDetails parentNodeTemplate;
- private final IEntityDetails parentNode;
-
- EntityDetails(EntityTemplate entityTemplate, NodeTemplate parentNode) {
+ EntityDetails(EntityTemplate entityTemplate) {
this.entityTemplate = entityTemplate;
- this.parentNode = EntityDetailsFactory.createEntityDetails(EntityTemplateType.NODE_TEMPLATE, parentNode, null);
+ this.parentNodeTemplate = EntityDetailsFactory.createEntityDetails(EntityTemplateType.NODE_TEMPLATE, entityTemplate.getParentNodeTemplate());
}
@Override
}
@Override
- public List<Property> getPropertyList() {
- return entityTemplate.getPropertiesObjects();
+ public List<IEntityDetails> getMemberNodes() {
+ return Collections.emptyList();
}
@Override
- public List<IEntityDetails> getMemberNodes() {
- List<IEntityDetails> ntList = new ArrayList<>();
- ntList.add(getParent());
- return ntList;
+ public IEntityDetails getParent() {
+ return parentNodeTemplate;
}
@Override
- public IEntityDetails getParent() {
- //todo - update after adding parent to the EntityTemplate class
- return parentNode;
+ public Map<String, RequirementAssignment> getRequirements() {
+ return entityTemplate.getRequirements()
+ .getAll()
+ .stream()
+ .collect(Collectors.toMap(RequirementAssignment::getName, ra->ra));
+ }
+
+ @Override
+ public Map<String, CapabilityAssignment> getCapabilities() {
+ return entityTemplate.getCapabilities()
+ .getAll()
+ .stream()
+ .collect(Collectors.toMap(CapabilityAssignment::getName, ca->ca));
+ }
+
+ @Override
+ public List<String> getTargets() {
+ return Collections.emptyList();
+ }
+
+ @Override
+ public List<IEntityDetails> getTargetNodes() {
+ return Collections.emptyList();
}
@Override
public String getPath() {
- //todo - update after adding parent to the EntityTemplate class
- return "jenny vTSBC vlan VNF 0#abstract_ssc#ssc_ssc_avpn_port_0";
+ StringBuilder pathBld = new StringBuilder("");
+ EntityTemplate currentEntityParent = entityTemplate.getParentNodeTemplate();
+
+ while (currentEntityParent != null) {
+ if (pathBld.length() != 0) {
+ pathBld.insert(0,"#");
+ }
+ pathBld.insert(0, currentEntityParent.getName());
+ currentEntityParent = currentEntityParent.getParentNodeTemplate();
+ }
+ return pathBld.toString();
}
import org.onap.sdc.tosca.parser.enums.EntityTemplateType;
import org.onap.sdc.toscaparser.api.EntityTemplate;
-import org.onap.sdc.toscaparser.api.NodeTemplate;
public class EntityDetailsFactory {
private EntityDetailsFactory(){}
- //TODO: the parent should be retrieved from the entityTemplate and not passed as a separate parameter
- public static EntityDetails createEntityDetails(EntityTemplateType entityTemplateType, EntityTemplate entityTemplate, NodeTemplate parent) {
+ public static EntityDetails createEntityDetails(EntityTemplateType entityTemplateType, EntityTemplate entityTemplate) {
EntityDetails entityDetails = null;
- if (entityTemplate != null) {
+ if (entityTemplate != null && entityTemplateType != null) {
switch (entityTemplateType) {
case NODE_TEMPLATE:
- entityDetails = new NodeTemplateEntityDetails(entityTemplate, parent);
+ entityDetails = new NodeTemplateEntityDetails(entityTemplate);
break;
case POLICY:
- entityDetails = new PolicyEntityDetails(entityTemplate, parent);
+ entityDetails = new PolicyEntityDetails(entityTemplate);
break;
case GROUP:
- entityDetails = new GroupEntityDetails(entityTemplate, parent);
+ entityDetails = new GroupEntityDetails(entityTemplate);
+ break;
+ default:
break;
}
}
import org.onap.sdc.tosca.parser.enums.EntityTemplateType;
import org.onap.sdc.toscaparser.api.EntityTemplate;
import org.onap.sdc.toscaparser.api.Group;
-import org.onap.sdc.toscaparser.api.NodeTemplate;
import org.onap.sdc.toscaparser.api.elements.Metadata;
+import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
public class GroupEntityDetails extends EntityDetails {
private final Group group;
+ private final List<IEntityDetails> memberNodes;
- GroupEntityDetails(EntityTemplate entityTemplate, NodeTemplate parentNode) {
- super(entityTemplate,parentNode);
+ GroupEntityDetails(EntityTemplate entityTemplate) {
+ super(entityTemplate);
group = (Group)getEntityTemplate();
+ if (group.getMemberNodes() != null) {
+ memberNodes = group.getMemberNodes()
+ .stream()
+ .map(m->EntityDetailsFactory.createEntityDetails(EntityTemplateType.NODE_TEMPLATE, m))
+ .collect(Collectors.toList());
+ }
+ else {
+ memberNodes = Collections.emptyList();
+ }
}
@Override
@Override
public List<IEntityDetails> getMemberNodes() {
- return group.getMemberNodes()
- .stream()
- .map(m->EntityDetailsFactory.createEntityDetails(EntityTemplateType.NODE_TEMPLATE, m, null))
- .collect(Collectors.toList());
+ return memberNodes;
}
@Override
private final NodeTemplate nodeTemplate;
- NodeTemplateEntityDetails(EntityTemplate entityTemplate, NodeTemplate parentNode) {
- super(entityTemplate, parentNode);
+ NodeTemplateEntityDetails(EntityTemplate entityTemplate) {
+ super(entityTemplate);
nodeTemplate = (NodeTemplate)getEntityTemplate();
}
package org.onap.sdc.tosca.parser.elements;
+import org.onap.sdc.tosca.parser.api.IEntityDetails;
import org.onap.sdc.tosca.parser.enums.EntityTemplateType;
import org.onap.sdc.toscaparser.api.EntityTemplate;
-import org.onap.sdc.toscaparser.api.NodeTemplate;
import org.onap.sdc.toscaparser.api.Policy;
import org.onap.sdc.toscaparser.api.elements.Metadata;
+import java.util.List;
+import java.util.stream.Collectors;
+
public class PolicyEntityDetails extends EntityDetails {
+ private static final String NODE_TEMPLATES_TARGET_TYPE = "node_templates";
+
private final Policy policy;
- PolicyEntityDetails(EntityTemplate entityTemplate, NodeTemplate parentNode) {
- super(entityTemplate, parentNode);
+ PolicyEntityDetails(EntityTemplate entityTemplate) {
+ super(entityTemplate);
policy = (Policy)getEntityTemplate();
}
public Metadata getMetadata() {
return policy.getMetaDataObj();
}
+
+ @Override
+ public List<String> getTargets() {
+ if (policy.getTargets() != null) {
+ return policy.getTargets();
+ }
+ return super.getTargets();
+ }
+
+ @Override
+ public List<IEntityDetails> getTargetNodes() {
+ if (policy.getTargetsType().equals(NODE_TEMPLATES_TARGET_TYPE)) {
+ return policy.getTargetsList()
+ .stream()
+ .map(o->EntityDetailsFactory.createEntityDetails(EntityTemplateType.NODE_TEMPLATE, (EntityTemplate)o))
+ .collect(Collectors.toList());
+ }
+ return policy.getTargetsList()
+ .stream()
+ .map(o->EntityDetailsFactory.createEntityDetails(EntityTemplateType.GROUP, (EntityTemplate)o))
+ .collect(Collectors.toList());
+ }
}
--- /dev/null
+package org.onap.sdc.tosca.parser.elements.queries;
+
+import com.google.common.collect.Lists;
+import org.onap.sdc.tosca.parser.api.IEntityDetails;
+import org.onap.sdc.tosca.parser.enums.EntityTemplateType;
+import org.onap.sdc.toscaparser.api.NodeTemplate;
+import org.onap.sdc.toscaparser.api.ToscaTemplate;
+
+import java.util.List;
+
+/**
+ * Implements EntityQuery object for NodeTemplates, Groups and Policies
+ */
+
+public class AllEntitiesQuery extends EntityQuery {
+
+ AllEntitiesQuery() {
+ super(EntityTemplateType.ALL, null, null);
+ }
+
+ @Override
+ public List<IEntityDetails> getEntitiesFromTopologyTemplate(NodeTemplate nodeTemplate) {
+ List<IEntityDetails> allEntities = Lists.newArrayList();
+ if (nodeTemplate.getSubMappingToscaTemplate() != null) {
+ allEntities.addAll(GroupEntityQuery.convertGroupLisToEntityDetailsList(nodeTemplate.getSubMappingToscaTemplate().getGroups().stream()));
+ allEntities.addAll(NodeTemplateEntityQuery.convertNodeTemplatesListToEntityDetailsList(nodeTemplate.getSubMappingToscaTemplate().getNodeTemplates().stream()));
+ }
+ if (nodeTemplate.getOriginComponentTemplate() != null) {
+ allEntities.addAll(PolicyEntityQuery.convertPolicyLisToEntityDetailsList(nodeTemplate.getOriginComponentTemplate().getPolicies().stream()));
+ }
+ return allEntities;
+ }
+
+
+ @Override
+ public List<IEntityDetails> getEntitiesFromService(ToscaTemplate toscaTemplate) {
+ List<IEntityDetails> allEntities = Lists.newArrayList();
+ allEntities.addAll(GroupEntityQuery.convertGroupLisToEntityDetailsList(toscaTemplate.getGroups().stream()));
+ allEntities.addAll(NodeTemplateEntityQuery.convertNodeTemplatesListToEntityDetailsList(toscaTemplate.getNodeTemplates().stream()));
+ allEntities.addAll(PolicyEntityQuery.convertPolicyLisToEntityDetailsList(toscaTemplate.getPolicies().stream()));
+ return allEntities;
+ }
+
+}
+
+
package org.onap.sdc.tosca.parser.elements.queries;
-import org.apache.commons.lang3.StringUtils;
+import org.onap.sdc.tosca.parser.api.IEntityDetails;
import org.onap.sdc.tosca.parser.enums.EntityTemplateType;
import org.onap.sdc.tosca.parser.enums.SdcTypes;
-import org.onap.sdc.toscaparser.api.EntityTemplate;
+import org.onap.sdc.tosca.parser.impl.SdcPropertyNames;
+import org.onap.sdc.toscaparser.api.NodeTemplate;
+import org.onap.sdc.toscaparser.api.ToscaTemplate;
+import org.onap.sdc.toscaparser.api.elements.Metadata;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import java.util.List;
+import java.util.Objects;
/**
* This class describes an entity searched and retrieved by SDC Tosca Parser API
*/
public abstract class EntityQuery {
+ private static final Logger logger = LoggerFactory.getLogger(EntityQuery.class.getName());
+
private final EntityTemplateType entityType;
private final SdcTypes nodeTemplateType;
this.customizationUUID = customizationUUID;
}
- public abstract List<EntityTemplate> searchByTopologyTemplate(TopologyTemplateQuery topologyTemplateQuery);
+ public abstract List<IEntityDetails> getEntitiesFromTopologyTemplate(NodeTemplate nodeTemplate);
- public abstract EntityTemplateType getType();
+ public abstract List<IEntityDetails> getEntitiesFromService(ToscaTemplate toscaTemplate);
public EntityTemplateType getEntityType() {
return entityType;
return customizationUUID;
}
- public boolean searchAllEntities() {
- return StringUtils.isEmpty(toscaType) && nodeTemplateType == null;
+ boolean isSearchCriteriaMatched(Metadata metadata, String toscaType, String uuidKeyName, String cuuidKeyName) {
+ return Objects.nonNull(metadata)
+ && isStringMatchingOrNull(metadata.getValue(uuidKeyName), getUUID())
+ && isStringMatchingOrNull(metadata.getValue(cuuidKeyName), getCustomizationUUID())
+ && isStringMatchingOrNull(toscaType, getToscaType());
+ }
+
+ boolean isSearchCriteriaMatched(Metadata metadata, String toscaType) {
+ return isSearchCriteriaMatched(metadata, toscaType, SdcPropertyNames.PROPERTY_NAME_UUID, SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID);
+ }
+
+ static boolean isStringMatchingOrNull(String currentUid, String uidInQuery) {
+ return uidInQuery == null || uidInQuery.equals(currentUid);
}
public static EntityQueryBuilder newBuilder(EntityTemplateType entityTemplateType) {
return new EntityQueryBuilder(sdcType);
}
+ @Override
+ public String toString() {
+ return String.format("EntityType=%s, nodeTemplateType=%s, toscaType=%s, uUID=%s, customizationUUID=%s",
+ entityType, nodeTemplateType, toscaType, uUID, customizationUUID);
+ }
+
public static EntityQueryBuilder newBuilder(String toscaType) {
return new EntityQueryBuilder(toscaType);
}
case POLICY:
entityQuery = new PolicyEntityQuery();
break;
+ case ALL:
+ entityQuery = new AllEntitiesQuery();
+ break;
default:
- throw new IllegalArgumentException("Wrong entity query type: " + entityTemplateType);
+ String wrongTypeMsg = (String.format("Wrong entity query type: %s", entityTemplateType));
+ logger.error(wrongTypeMsg);
+ throw new IllegalArgumentException(wrongTypeMsg);
}
}
package org.onap.sdc.tosca.parser.elements.queries;
+import com.google.common.collect.Lists;
+import org.onap.sdc.tosca.parser.api.IEntityDetails;
+import org.onap.sdc.tosca.parser.elements.EntityDetailsFactory;
import org.onap.sdc.tosca.parser.enums.EntityTemplateType;
-import org.onap.sdc.toscaparser.api.EntityTemplate;
+import org.onap.sdc.toscaparser.api.Group;
+import org.onap.sdc.toscaparser.api.NodeTemplate;
+import org.onap.sdc.toscaparser.api.ToscaTemplate;
import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
/**
* Implements EntityQuery object for Groups
*/
public class GroupEntityQuery extends EntityQuery {
- public GroupEntityQuery() {
+ private static final String VF_MODULE_UUID = "vfModuleModelUUID";
+ private static final String VF_MODULE_CUSTOMIZATION_UUID = "vfModuleModelCustomizationUUID";
+
+ GroupEntityQuery() {
super(EntityTemplateType.GROUP, null, null);
}
@Override
- public List<EntityTemplate> searchByTopologyTemplate(TopologyTemplateQuery topologyTemplateQuery) {
- return null;
+ public List<IEntityDetails> getEntitiesFromTopologyTemplate(NodeTemplate nodeTemplate) {
+ if (nodeTemplate.getSubMappingToscaTemplate() != null) {
+ return convertGroupLisToEntityDetailsList(filter(nodeTemplate.getSubMappingToscaTemplate().getGroups()));
+ }
+ return Lists.newArrayList();
}
@Override
- public EntityTemplateType getType() {
- return EntityTemplateType.GROUP;
+ public List<IEntityDetails> getEntitiesFromService(ToscaTemplate toscaTemplate) {
+ return convertGroupLisToEntityDetailsList(filter(toscaTemplate.getGroups()));
}
- public GroupEntityQuery(String toscaType) {
+ GroupEntityQuery(String toscaType) {
super(EntityTemplateType.GROUP, null, toscaType);
}
+
+ static List<IEntityDetails> convertGroupLisToEntityDetailsList(Stream<Group> groups) {
+ return groups.map(gr->EntityDetailsFactory.createEntityDetails(EntityTemplateType.GROUP, gr))
+ .collect(Collectors.toList());
+ }
+
+ private Stream<Group> filter(List<Group> groupList) {
+ return groupList.stream()
+ .filter(gr->isSearchCriteriaMatched(gr.getMetadata(), gr.getType()) ||
+ isSearchCriteriaMatched(gr.getMetadata(), gr.getType(), VF_MODULE_UUID, VF_MODULE_CUSTOMIZATION_UUID));
+ }
+
}
package org.onap.sdc.tosca.parser.elements.queries;
+import com.google.common.collect.Lists;
+import org.onap.sdc.tosca.parser.api.IEntityDetails;
+import org.onap.sdc.tosca.parser.elements.EntityDetailsFactory;
import org.onap.sdc.tosca.parser.enums.EntityTemplateType;
import org.onap.sdc.tosca.parser.enums.SdcTypes;
-import org.onap.sdc.toscaparser.api.EntityTemplate;
+import org.onap.sdc.tosca.parser.impl.SdcPropertyNames;
+import org.onap.sdc.toscaparser.api.NodeTemplate;
+import org.onap.sdc.toscaparser.api.ToscaTemplate;
import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
/**
* Implements EntityQuery object for NodeTemplates
*/
public class NodeTemplateEntityQuery extends EntityQuery {
- public NodeTemplateEntityQuery() {
+ NodeTemplateEntityQuery() {
super(EntityTemplateType.NODE_TEMPLATE, null, null);
}
+ NodeTemplateEntityQuery(SdcTypes nodeTemplateType) {
+ super(EntityTemplateType.NODE_TEMPLATE, nodeTemplateType, null);
+ }
+
+ NodeTemplateEntityQuery(String toscaType) {
+ super(EntityTemplateType.NODE_TEMPLATE, null, toscaType);
+ }
+
@Override
- public EntityTemplateType getType() {
- return EntityTemplateType.NODE_TEMPLATE;
+ public List<IEntityDetails> getEntitiesFromTopologyTemplate(NodeTemplate nodeTemplate) {
+ if (nodeTemplate.getSubMappingToscaTemplate() != null) {
+ return convertNodeTemplatesListToEntityDetailsList(filter(nodeTemplate.getSubMappingToscaTemplate()
+ .getNodeTemplates()));
+ }
+ return Lists.newArrayList();
}
@Override
- public List<EntityTemplate> searchByTopologyTemplate(TopologyTemplateQuery topologyTemplateQuery) {
- return null;
+ public List<IEntityDetails> getEntitiesFromService(ToscaTemplate toscaTemplate) {
+ return convertNodeTemplatesListToEntityDetailsList(filter(toscaTemplate.getNodeTemplates()));
}
- public NodeTemplateEntityQuery(SdcTypes nodeTemplateType) {
- super(EntityTemplateType.NODE_TEMPLATE, nodeTemplateType, null);
+ static List<IEntityDetails> convertNodeTemplatesListToEntityDetailsList(Stream<NodeTemplate> nodeTemplates) {
+ return nodeTemplates
+ .map(nt->EntityDetailsFactory.createEntityDetails(EntityTemplateType.NODE_TEMPLATE, nt))
+ .collect(Collectors.toList());
}
- public NodeTemplateEntityQuery(String toscaType) {
- super(EntityTemplateType.NODE_TEMPLATE, null, toscaType);
+ private Stream<NodeTemplate> filter(List<NodeTemplate> nodeTemplateList) {
+ return nodeTemplateList.stream()
+ .filter(nt->isSearchCriteriaMatched(nt.getMetaData(), nt.getType()))
+ .filter(nt->getNodeTemplateType() == null ||
+ isStringMatchingOrNull(nt.getMetaData().getValue(SdcPropertyNames.PROPERTY_NAME_TYPE),
+ getNodeTemplateType().getValue()));
}
+
+
}
package org.onap.sdc.tosca.parser.elements.queries;
+import com.google.common.collect.Lists;
+import org.onap.sdc.tosca.parser.api.IEntityDetails;
+import org.onap.sdc.tosca.parser.elements.EntityDetailsFactory;
import org.onap.sdc.tosca.parser.enums.EntityTemplateType;
-import org.onap.sdc.toscaparser.api.EntityTemplate;
+import org.onap.sdc.toscaparser.api.NodeTemplate;
+import org.onap.sdc.toscaparser.api.Policy;
+import org.onap.sdc.toscaparser.api.ToscaTemplate;
import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
/**
* Implements EntityQuery object for Policies
*/
public class PolicyEntityQuery extends EntityQuery {
- public PolicyEntityQuery() {
+ PolicyEntityQuery() {
super(EntityTemplateType.POLICY, null, null);
}
+ PolicyEntityQuery(String toscaType) {
+ super(EntityTemplateType.POLICY, null, toscaType);
+ }
+
@Override
- public List<EntityTemplate> searchByTopologyTemplate(TopologyTemplateQuery topologyTemplateQuery) {
- return null;
+ public List<IEntityDetails> getEntitiesFromTopologyTemplate(NodeTemplate nodeTemplate) {
+ if (nodeTemplate.getOriginComponentTemplate() != null) {
+ return convertPolicyLisToEntityDetailsList(filter(nodeTemplate.getOriginComponentTemplate().getPolicies()));
+ }
+ return Lists.newArrayList();
}
@Override
- public EntityTemplateType getType() {
- return EntityTemplateType.POLICY;
+ public List<IEntityDetails> getEntitiesFromService(ToscaTemplate toscaTemplate) {
+ return convertPolicyLisToEntityDetailsList(filter(toscaTemplate.getPolicies()));
}
- public PolicyEntityQuery(String toscaType) {
- super(EntityTemplateType.POLICY, null, toscaType);
+ static List<IEntityDetails> convertPolicyLisToEntityDetailsList(Stream<Policy> policies) {
+ return policies
+ .map(p->EntityDetailsFactory.createEntityDetails(EntityTemplateType.POLICY, p))
+ .collect(Collectors.toList());
}
+
+ private Stream<Policy> filter(List<Policy> policyList) {
+ return policyList.stream()
+ .filter(p->isSearchCriteriaMatched(p.getMetaDataObj(), p.getType()));
+ }
+
}
package org.onap.sdc.tosca.parser.elements.queries;
import org.onap.sdc.tosca.parser.enums.SdcTypes;
+import org.onap.sdc.tosca.parser.impl.SdcPropertyNames;
+import org.onap.sdc.toscaparser.api.NodeTemplate;
+import org.onap.sdc.toscaparser.api.elements.Metadata;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Objects;
/**
* This class describes a node template instance containing an entity searched and retrieved by SDC Tosca Parser API
* It is used as the API input parameter. See the {@link org.onap.sdc.tosca.parser.api.ISdcCsarHelper}
*/
public class TopologyTemplateQuery {
+ private static final Logger logger = LoggerFactory.getLogger(TopologyTemplateQuery.class.getName());
- public void setCustomizationUUID(String customizationUUID) {
+ void setCustomizationUUID(String customizationUUID) {
this.customizationUUID = customizationUUID;
}
}
public static TopologyTemplateQueryBuilder newBuilder(SdcTypes sdcType) {
+ if (!SdcTypes.isComplex(sdcType.getValue())) {
+ String wrongTypeMsg = (String.format("Given type is not Topology template %s", sdcType));
+ logger.error(wrongTypeMsg);
+ throw new IllegalArgumentException(wrongTypeMsg);
+ }
return new TopologyTemplateQueryBuilder(sdcType);
}
return customizationUUID;
}
+ public Boolean isMatchingSearchCriteria(NodeTemplate nodeTemplate) {
+ boolean isMatched = Objects.nonNull(nodeTemplate.getMetaData()) && isSearchedTemplate(nodeTemplate.getMetaData());
+ if(logger.isDebugEnabled()) {
+ logger.debug("Node template {} is{} matching search criteria", nodeTemplate.getName(), isMatched ? "" : " not");
+ }
+ return isMatched;
+ }
+
+ public boolean isSameSdcType(Metadata metadata) {
+ final String nodeType = metadata.getValue(SdcPropertyNames.PROPERTY_NAME_TYPE);
+ return Objects.nonNull(nodeType) && (
+ sdcType.getValue().equals(nodeType) || isServiceSearched(nodeType));
+ }
+
+ private boolean isSearchedTemplate(Metadata metadata) {
+ return isSameSdcType(metadata) &&
+ (sdcType == SdcTypes.SERVICE ||
+ //don't check customizationUUID for service
+ EntityQuery.isStringMatchingOrNull(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID),
+ getCustomizationUUID()));
+ }
+
+ private boolean isServiceSearched(String nodeType) {
+ return sdcType == SdcTypes.SERVICE && SdcTypes.isComplex(nodeType);
+ }
+
+ @Override
+ public String toString() {
+ return String.format("sdcType=%s, customizationUUID=%s", sdcType.getValue(), customizationUUID);
+ }
+
public static class TopologyTemplateQueryBuilder {
private TopologyTemplateQuery topologyTemplateQuery;
private TopologyTemplateQueryBuilder(SdcTypes sdcType) { topologyTemplateQuery = new TopologyTemplateQuery(sdcType);}
public enum EntityTemplateType {
NODE_TEMPLATE,
GROUP,
- POLICY;
+ POLICY,
+ ALL;
}
public enum SdcTypes {
- CP("CP"), VL("VL"), VF("VF"), CR("CR"), VFC("VFC"), PNF("PNF"), SERVICE("Service"), CVFC("CVFC"), SERVICE_PROXY("Service Proxy"), CONFIGURATION("Configuration");
+ CP("CP"), VL("VL"), VF("VF"), CR("CR"), VFC("VFC"), PNF("PNF"), SERVICE("Service"), CVFC("CVFC"),
+ SERVICE_PROXY("Service Proxy"), CONFIGURATION("Configuration"), VFC_ALLOTTED_RESOURCE("AllottedResource") ;
private String value;
--- /dev/null
+package org.onap.sdc.tosca.parser.impl;
+
+import com.google.common.collect.Lists;
+import org.onap.sdc.tosca.parser.api.IEntityDetails;
+import org.onap.sdc.tosca.parser.elements.queries.EntityQuery;
+import org.onap.sdc.tosca.parser.elements.queries.TopologyTemplateQuery;
+import org.onap.sdc.tosca.parser.enums.EntityTemplateType;
+import org.onap.sdc.tosca.parser.enums.SdcTypes;
+import org.onap.sdc.toscaparser.api.NodeTemplate;
+import org.onap.sdc.toscaparser.api.ToscaTemplate;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * Performs search for entity templates inside node template according to query criteria
+ */
+class QueryProcessor {
+ private static final Logger logger = LoggerFactory.getLogger(QueryProcessor.class.getName());
+
+ private final EntityQuery entityQuery;
+ private final TopologyTemplateQuery topologyTemplateQuery;
+ private final ToscaTemplate toscaTemplate;
+ private boolean isRecursive = false;
+
+ QueryProcessor(ToscaTemplate toscaTemplate, EntityQuery entityQuery, TopologyTemplateQuery topologyTemplateQuery, boolean isRecursive) {
+ this.toscaTemplate = toscaTemplate;
+ this.entityQuery = entityQuery == null ? EntityQuery.newBuilder(EntityTemplateType.ALL).build() : entityQuery;
+ this.topologyTemplateQuery = topologyTemplateQuery;
+ this.isRecursive = isRecursive;
+ }
+
+ List<IEntityDetails> doQuery() {
+ List<IEntityDetails> entityDetailsList = Lists.newArrayList();
+ if (isServiceSearch()) {
+ //search for entities inside the service
+ if (logger.isDebugEnabled()) {
+ logger.debug("Service {} is searched for {}", toscaTemplate.getMetaData().getValue(SdcPropertyNames.PROPERTY_NAME_NAME), entityQuery);
+ }
+ entityDetailsList.addAll(entityQuery.getEntitiesFromService(toscaTemplate));
+
+ if (!isRecursive) {
+ return entityDetailsList;
+ }
+ }
+
+ List<NodeTemplate> foundTopologyTemplates = getInternalTopologyTemplates(toscaTemplate.getNodeTemplates(), false);
+ if (isRecursive) {
+ if (logger.isDebugEnabled()) {
+ logger.debug("Search for entities recursively");
+ }
+ //go over internal topology templates of the found templates
+ // and search for instances of the same type
+ //if the queried topology template is "SERVICE", search for all instances of templates in the service
+ List<NodeTemplate> internalTopologyTemplates = foundTopologyTemplates.stream()
+ .filter(nt->nt.getSubMappingToscaTemplate() != null)
+ .map(nt->getInternalTopologyTemplates(nt.getSubMappingToscaTemplate().getNodeTemplates(), true))
+ .flatMap(List::stream)
+ .collect(Collectors.toList());
+ foundTopologyTemplates.addAll(internalTopologyTemplates);
+ }
+ if (logger.isDebugEnabled()) {
+ logger.debug("Found topology templates {} matching following query criteria: {}",
+ foundTopologyTemplates, topologyTemplateQuery);
+ }
+ //go over all node templates found according to query criteria and recursive flag and
+ // search for the requested entities.
+ entityDetailsList.addAll(searchEntitiesInsideTopologyTemplates(foundTopologyTemplates));
+
+ return entityDetailsList;
+ }
+
+ private Map<String, NodeTemplate> convertListToMap(List<NodeTemplate> nodeTemplateList) {
+ // we use map to avoid duplicate search through same node templates
+ return nodeTemplateList.stream()
+ .collect(Collectors.toMap(NodeTemplate::getName, nt->nt, (nt1, nt2)->nt1));
+ }
+
+ private List<IEntityDetails> searchEntitiesInsideTopologyTemplates(List<NodeTemplate> foundTopologyTemplates) {
+ return convertListToMap(foundTopologyTemplates)
+ .values()
+ .stream()
+ .map(entityQuery::getEntitiesFromTopologyTemplate)
+ .flatMap(List::stream)
+ .collect(Collectors.toList());
+ }
+
+ private boolean isServiceSearch() {
+ return topologyTemplateQuery.getNodeTemplateType() == SdcTypes.SERVICE;
+ }
+
+ private List<NodeTemplate> getInternalTopologyTemplates(List<NodeTemplate> nodeTemplateList, boolean searchTypeOnly) {
+ return nodeTemplateList
+ .stream()
+ .map(child->getTopologyTemplatesByQuery(child, searchTypeOnly))
+ .flatMap(List::stream)
+ .collect(Collectors.toList());
+ }
+
+ private List<NodeTemplate> getTopologyTemplatesByQuery(NodeTemplate current, boolean searchTypeOnly) {
+ List<NodeTemplate> topologyTemplateList = Lists.newArrayList();
+
+ boolean isTopologyTemplateFound = searchTypeOnly ?
+ topologyTemplateQuery.isSameSdcType(current.getMetaData()) : topologyTemplateQuery.isMatchingSearchCriteria(current);
+ if (isTopologyTemplateFound) {
+ topologyTemplateList.add(current);
+ if (!isServiceSearch()) {
+ //recursion stop condition
+ return topologyTemplateList;
+ }
+ }
+ if (SdcTypes.isComplex(current.getMetaData().getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)) && current.getSubMappingToscaTemplate() != null) {
+ //search the node template inside a given topology template
+ topologyTemplateList.addAll(current.getSubMappingToscaTemplate().getNodeTemplates()
+ .stream()
+ .map(nt->getTopologyTemplatesByQuery(nt, searchTypeOnly))
+ .flatMap(List::stream)
+ .collect(Collectors.toList()));
+ }
+ return topologyTemplateList;
+ }
+
+
+}
import org.onap.sdc.tosca.parser.api.IEntityDetails;
import org.onap.sdc.tosca.parser.api.ISdcCsarHelper;
import org.onap.sdc.tosca.parser.config.ConfigurationManager;
-import org.onap.sdc.tosca.parser.elements.EntityDetailsFactory;
-import org.onap.sdc.tosca.parser.elements.NodeTemplateEntityDetails;
-import org.onap.sdc.tosca.parser.elements.queries.TopologyTemplateQuery;
import org.onap.sdc.tosca.parser.elements.queries.EntityQuery;
-import org.onap.sdc.tosca.parser.enums.EntityTemplateType;
+import org.onap.sdc.tosca.parser.elements.queries.TopologyTemplateQuery;
import org.onap.sdc.tosca.parser.enums.FilterType;
import org.onap.sdc.tosca.parser.enums.PropertySchemaType;
import org.onap.sdc.tosca.parser.enums.SdcTypes;
@Override
public List<IEntityDetails> getEntity(EntityQuery entityQuery, TopologyTemplateQuery topologyTemplateQuery, boolean isRecursive) {
- List<IEntityDetails> foundEntities = new ArrayList<>();
- List<NodeTemplate> vfcList = getVfcListByVf("05e77410-a1d8-44fe-8440-b9410c8f98ee");
- NodeTemplate vfc = getNodeTemplateByCustomizationUuid(vfcList, "1fdc9625-dfec-48e1-aaf8-7b92f78ca854");
- NodeTemplate cp = getChildNodeTemplateByName(vfc, "ssc_ssc_avpn_port_0");
- foundEntities.add(EntityDetailsFactory.createEntityDetails(EntityTemplateType.NODE_TEMPLATE, cp, vfc));
- return foundEntities;
+
+ if (log.isDebugEnabled()) {
+ log.debug("getEntity request: EntityQuery <{}>, TopologyTemplateQuery <{}>, isRecursive<{}>",
+ entityQuery, topologyTemplateQuery, isRecursive);
+ }
+ return new QueryProcessor(toscaTemplate, entityQuery, topologyTemplateQuery, isRecursive).doQuery();
}
+
}
import org.onap.sdc.tosca.parser.enums.EntityTemplateType;
import org.onap.sdc.tosca.parser.enums.SdcTypes;
import org.onap.sdc.tosca.parser.exceptions.SdcToscaParserException;
+import org.onap.sdc.tosca.parser.impl.SdcPropertyNames;
import org.onap.sdc.tosca.parser.impl.SdcToscaParserFactory;
+import org.onap.sdc.toscaparser.api.CapabilityAssignment;
import org.onap.sdc.toscaparser.api.Property;
+import java.net.URL;
import java.util.List;
import java.util.Map;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
public class GetEntityTest {
@BeforeClass
public static void setUpClass() {
try {
- String filePath = GetEntityTest.class.getClassLoader().getResource("csars/service-JennyVtsbcVlanSvc-csar.csar").getFile();
- helper = SdcToscaParserFactory.getInstance().getSdcCsarHelper(filePath);
+ URL resource = GetEntityTest.class.getClassLoader().getResource("csars/service-JennyVtsbcVlanSvc-csar.csar");
+ if (resource != null) {
+ helper = SdcToscaParserFactory.getInstance().getSdcCsarHelper(resource.getFile());
+ }
+
} catch (SdcToscaParserException e) {
e.printStackTrace();
}
}
- @Test
- public void test1() {
- //none recursive search for groups in the service
- EntityQuery entityQuery1 = EntityQuery.newBuilder(EntityTemplateType.GROUP)
- .uUID("1233456")
+ @Test
+ public void getCpEntitiesFromCVFC() {
+ EntityQuery entityQuery = EntityQuery.newBuilder(SdcTypes.CP)
+ .build();
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.CVFC)
+ .customizationUUID("1fdc9625-dfec-48e1-aaf8-7b92f78ca854")
.build();
- TopologyTemplateQuery topologyTemplateQuery1 = TopologyTemplateQuery.newBuilder(SdcTypes.SERVICE)
+ List<IEntityDetails> entities = helper.getEntity(entityQuery, topologyTemplateQuery, false);
+
+ assertEquals(6, entities.size());
+ }
+
+ @Test
+ public void getOneCpEntityFromCVFC() {
+ EntityQuery entityQuery = EntityQuery.newBuilder("org.openecomp.resource.cp.v2.extNeutronCP")
+ .uUID("d5e13a34-c983-4a36-a44a-a53a6e850d73")
+ .customizationUUID("e97b3399-ab2d-4a34-b07a-9bd5f6461335")
+ .build();
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.CVFC)
+ .customizationUUID("1fdc9625-dfec-48e1-aaf8-7b92f78ca854")
.build();
- List<IEntityDetails> entities = helper.getEntity(entityQuery1, topologyTemplateQuery1, false);
- for (IEntityDetails entity: entities) {
- List<IEntityDetails> members = entity.getMemberNodes();
- }
+ List<IEntityDetails> entities = helper.getEntity(entityQuery, topologyTemplateQuery, false);
- //recursive search for CPs in a specific CVFC
- EntityQuery entityQuery2 = EntityQuery.newBuilder(SdcTypes.CP)
- .customizationUUID("345678903456")
+ assertEquals(1, entities.size());
+ assertEquals("ssc_ssc_avpn_port_0", entities.get(0).getName());
+ assertEquals(18, entities.get(0).getProperties().size());
+ assertEquals(1, entities.get(0).getRequirements().size());
+ assertEquals(13, entities.get(0).getCapabilities().entrySet().size());
+ Map<String, CapabilityAssignment> capAssignments = entities.get(0).getCapabilities();
+ CapabilityAssignment capabilityAssignment = capAssignments.get("network.outgoing.packets.rate");
+ assertEquals("org.openecomp.capabilities.metric.Ceilometer", capabilityAssignment.getDefinition().getType());
+
+ }
+
+ @Test
+ public void getCpsFromCVFCRecursively() {
+ EntityQuery entityQuery = EntityQuery.newBuilder(SdcTypes.CP)
+ .build();
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.CVFC)
.build();
- TopologyTemplateQuery topologyTemplateQuery2 = TopologyTemplateQuery.newBuilder(SdcTypes.CVFC)
- .customizationUUID("12346767676")
+ List<IEntityDetails> entities = helper.getEntity(entityQuery, topologyTemplateQuery, true);
+
+ assertEquals(16, entities.size());
+ assertEquals("jenny vTSBC vlan VNF 0#abstract_rtp_msc", entities.get(2).getPath());
+ assertEquals("jenny vTSBC vlan VNF 0#abstract_rtp_msc#rtp_msc_rtp_msc_avpn_port_0_vlan_subinterface_rtp_msc_avpn", entities.get(7).getPath());
+ }
+
+ @Test
+ public void getCpByUuidsFromCVFCRecursively() {
+ EntityQuery entityQuery = EntityQuery.newBuilder(SdcTypes.CP)
+ .customizationUUID("d674b231-34ba-4777-b83a-78be33960a69")
+ .uUID("f511e1c8-1f21-4370-b7b6-f57a61c15211")
+ .build();
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.CVFC)
.build();
- entities = helper.getEntity(entityQuery2, topologyTemplateQuery2, true);
- for (IEntityDetails entity: entities) {
- Map<String, Property> properties = entity.getProperties();
- Property property = properties.get("network_role");
- String network_role_value = (String) property.getValue();
- }
+ List<IEntityDetails> entities = helper.getEntity(entityQuery, topologyTemplateQuery, true);
+ assertEquals(1, entities.size());
+ assertEquals("rtp_msc_subint_mis_vmi_0", entities.get(0).getName());
+ assertEquals("ff9ae686-f030-4431-afb7-b65d1bf4733e", entities.get(0).getParent().getMetadata().getValue(SdcPropertyNames.PROPERTY_NAME_UUID));
+ assertTrue(entities.get(0).getMemberNodes().isEmpty());
}
@Test
- public void getCpEntityMock() {
+ public void getCpByWrongUuidFromCVFCRecursively() {
EntityQuery entityQuery = EntityQuery.newBuilder(SdcTypes.CP)
+ .customizationUUID("d674b231-34ba-4777-b83a-78be33960a69")
+ .uUID("f511e1c8-1f21-4370-b7b6-f57a61c15213")
.build();
TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.CVFC)
.build();
+ List<IEntityDetails> entities = helper.getEntity(entityQuery, topologyTemplateQuery, true);
+
+ assertEquals(0, entities.size());
+ }
+
+ @Test
+ public void getServiceGroups() {
+ EntityQuery entityQuery = EntityQuery.newBuilder(EntityTemplateType.GROUP)
+ .build();
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.SERVICE)
+ .build();
+
+ List<IEntityDetails> entities = helper.getEntity(entityQuery, topologyTemplateQuery, false);
+
+ assertEquals(4, entities.size());
+ assertTrue(entities.get(0).getRequirements().isEmpty());
+ assertTrue(entities.get(1).getCapabilities().isEmpty());
+ assertTrue(entities.get(0).getPath().isEmpty() && entities.get(1).getPath().isEmpty() &&
+ entities.get(2).getPath().isEmpty() && entities.get(3).getPath().isEmpty());
+ }
+
+ @Test
+ public void getVfGroupsByType1() {
+ EntityQuery entityQuery = EntityQuery.newBuilder("tosca.groups.Root")
+ .build();
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.VF)
+ .build();
+
+ List<IEntityDetails> entities = helper.getEntity(entityQuery, topologyTemplateQuery, false);
+
+ assertEquals(2, entities.size());
+ assertTrue(entities.get(0).getMemberNodes().get(0).getName().equals("abstract_rtp_msc") ||
+ entities.get(1).getMemberNodes().get(0).getName().equals("abstract_rtp_msc"));
+ assertTrue(entities.get(0).getMemberNodes().get(0).getName().equals("abstract_ssc") ||
+ entities.get(1).getMemberNodes().get(0).getName().equals("abstract_ssc"));
+
+ }
+
+ @Test
+ public void getVfGroupByType2() {
+ EntityQuery entityQuery = EntityQuery.newBuilder("org.openecomp.groups.VfcInstanceGroup")
+ .build();
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.VF)
+ .build();
+
+ List<IEntityDetails> entities = helper.getEntity(entityQuery, topologyTemplateQuery, false);
+
+ assertEquals(1, entities.size());
+ assertTrue(entities.get(0).getName().equals("avpn_group"));
+ assertTrue(entities.get(0).getMemberNodes().get(0).getName().equals("abstract_ssc") ||
+ entities.get(0).getMemberNodes().get(1).getName().equals("abstract_ssc"));
+ assertTrue(entities.get(0).getMemberNodes().get(0).getName().equals("abstract_rtp_msc") ||
+ entities.get(0).getMemberNodes().get(1).getName().equals("abstract_rtp_msc"));
+ assertEquals(4, entities.get(0).getProperties().size());
+ assertTrue(entities.get(0).getRequirements().isEmpty());
+
+ }
+
+ @Test
+ public void getOneServiceGroup() {
+ EntityQuery entityQuery = EntityQuery.newBuilder(EntityTemplateType.GROUP)
+ .customizationUUID("94d27f05-a116-4662-b330-8758c2b049d7")
+ .build();
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.SERVICE)
+ .build();
+
List<IEntityDetails> entities = helper.getEntity(entityQuery, topologyTemplateQuery, false);
assertEquals(1, entities.size());
- assertEquals(1, entities.get(0).getMemberNodes().size());
- assertEquals(EntityTemplateType.NODE_TEMPLATE, entities.get(0).getType());
- assertEquals("28.0", entities.get(0).getMetadata().getValue("version"));
- assertEquals("CP", entities.get(0).getMetadata().getValue("type"));
- assertEquals("extNeutronCP", entities.get(0).getMetadata().getValue("name"));
- assertEquals("abstract_ssc", entities.get(0).getParent().getName());
- assertEquals("jenny vTSBC vlan VNF 0#abstract_ssc#ssc_ssc_avpn_port_0", entities.get(0).getPath());
- assertTrue(entities.get(0).getProperties() != null && entities.get(0).getProperties().size() == 18);
+ assertNull(entities.get(0).getParent());
+ }
+ @Test
+ public void getAllGroups() {
+ EntityQuery entityQuery = EntityQuery.newBuilder(EntityTemplateType.GROUP)
+ .build();
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.SERVICE)
+ .build();
+
+ List<IEntityDetails> entities = helper.getEntity(entityQuery, topologyTemplateQuery, true);
+
+ assertEquals(19, entities.size());
+ assertTrue(entities.get(9).getTargetNodes().isEmpty());
+ assertEquals("rtp_msc_subint_avpn_vmi_0", entities.get(5).getMemberNodes().get(0).getName());
}
+
+ @Test
+ public void getAllPolicies() {
+ EntityQuery entityQuery = EntityQuery.newBuilder(EntityTemplateType.POLICY)
+ .build();
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.SERVICE)
+ .build();
+
+ List<IEntityDetails> entities = helper.getEntity(entityQuery, topologyTemplateQuery, true);
+
+ assertEquals(1, entities.size());
+ assertEquals("jennyvtsbcvlanvnf..External..0", entities.get(0).getMetadata().getValue(SdcPropertyNames.PROPERTY_NAME_NAME));
+ assertEquals(EntityTemplateType.GROUP, entities.get(0).getTargetNodes().get(0).getType());
+ assertEquals("jenny vTSBC vlan VNF 0", entities.get(0).getPath());
+ }
+
+ @Test
+ public void getServicePolicy() {
+ EntityQuery entityQuery = EntityQuery.newBuilder(EntityTemplateType.POLICY)
+ .build();
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.SERVICE)
+ .build();
+
+ List<IEntityDetails> entities = helper.getEntity(entityQuery, topologyTemplateQuery, false);
+ assertEquals(0, entities.size());
+ }
+
+ @Test
+ public void getVfPolicyByUUID() {
+ EntityQuery entityQuery = EntityQuery.newBuilder("org.openecomp.policies.External")
+ .uUID("0181f46a-3c68-47dd-9839-8692726356e5")
+ .build();
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.VF)
+ .build();
+
+ List<IEntityDetails> entities = helper.getEntity(entityQuery, topologyTemplateQuery, false);
+
+ assertEquals(1, entities.size());
+ assertEquals(EntityTemplateType.GROUP, entities.get(0).getTargetNodes().get(0).getType());
+ assertTrue(entities.get(0).getRequirements().isEmpty());
+ assertTrue(entities.get(0).getCapabilities().isEmpty());
+ assertEquals("jenny vTSBC vlan VNF 0", entities.get(0).getPath());
+ }
+
+ @Test
+ public void getVfPolicyByWrongToscaTypeAndUUID() {
+ EntityQuery entityQuery = EntityQuery.newBuilder("org.openecomp.policies.External1")
+ .uUID("0181f46a-3c68-47dd-9839-8692726356e5")
+ .build();
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.VF)
+ .build();
+
+ List<IEntityDetails> entities = helper.getEntity(entityQuery, topologyTemplateQuery, false);
+ assertEquals(0, entities.size());
+ }
+
+ @Test
+ public void getCvfcPolicyByToscaTypeAndUUID() {
+ EntityQuery entityQuery = EntityQuery.newBuilder("org.openecomp.policies.External")
+ .uUID("0181f46a-3c68-47dd-9839-8692726356e5")
+ .build();
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.CVFC)
+ .build();
+
+ List<IEntityDetails> entities = helper.getEntity(entityQuery, topologyTemplateQuery, true);
+ assertEquals(0, entities.size());
+ }
+
+
+ @Test
+ public void getAllEntitiesInServiceOnly() {
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.SERVICE)
+ .build();
+
+ List<IEntityDetails> entities = helper.getEntity(null, topologyTemplateQuery, false);
+ assertEquals(5, entities.size());
+ }
+
+
+ @Test
+ public void getAllEntitiesInServiceRecursively() {
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.SERVICE)
+ .build();
+
+ List<IEntityDetails> entities = helper.getEntity(null, topologyTemplateQuery, true);
+ assertEquals(48, entities.size());
+ }
+
+ @Test
+ public void getAllEntitiesInCvfcByCUUID() {
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.CVFC)
+ .customizationUUID("b90c9f8a-9c07-4507-913f-70b533f5934d")
+ .build();
+
+ List<IEntityDetails> entities = helper.getEntity(null, topologyTemplateQuery, false);
+ assertEquals(2, entities.size());
+ assertTrue("ssc_subint_mis_vmi_0".equals(entities.get(0).getName()) || "ssc_subint_mis_vmi_0".equals(entities.get(1).getName()));
+ }
+
+ @Test
+ public void getAllEntitiesInCvfcByUuidRecursively() {
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.CVFC)
+ .customizationUUID("1fdc9625-dfec-48e1-aaf8-7b92f78ca854")
+ .build();
+
+ List<IEntityDetails> entities = helper.getEntity(null, topologyTemplateQuery, true);
+ assertEquals(13, entities.size());
+ }
+
+ @Test
+ public void getCpPropertyWhenCpIsInInternalCVFC() {
+ EntityQuery entityQuery = EntityQuery.newBuilder("org.openecomp.resource.cp.nodes.heat.network.neutron.Port")
+ .customizationUUID("c03b7d04-5457-4ad2-9102-1edb7806c7b2")
+ .build();
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.CVFC)
+ .build();
+
+ List<IEntityDetails> entities = helper.getEntity(entityQuery, topologyTemplateQuery, true);
+
+ assertEquals(1, entities.size());
+ Property p = entities.get(0).getProperties().get("ip_requirements");
+ List<String> valueList = p.getLeafPropertyValue("ip_version");
+ assertEquals(1, valueList.size());
+ assertEquals("4", valueList.get(0));
+ }
+
+ @Test
+ public void getCpPropertyOnCVFC() {
+ EntityQuery entityQuery = EntityQuery.newBuilder("org.openecomp.resource.cp.v2.extNeutronCP")
+ .customizationUUID("e56919d1-b23f-4334-93b0-1daa507fd2a9")
+ .build();
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.CVFC)
+ .customizationUUID("1fdc9625-dfec-48e1-aaf8-7b92f78ca854")
+ .build();
+
+ List<IEntityDetails> entities = helper.getEntity(entityQuery, topologyTemplateQuery, false);
+
+ assertEquals(1, entities.size());
+ Property p = entities.get(0).getProperties().get("mac_requirements");
+ List<String> valueList = p.getLeafPropertyValue("mac_count_required#is_required");
+ assertEquals(1, valueList.size());
+ assertEquals("false", valueList.get(0));
+ }
+
}
--- /dev/null
+package org.onap.sdc.tosca.parser.elements;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.onap.sdc.tosca.parser.enums.EntityTemplateType;
+import org.onap.sdc.toscaparser.api.Group;
+import org.onap.sdc.toscaparser.api.NodeTemplate;
+import org.onap.sdc.toscaparser.api.Policy;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class EntityDetailsFactoryTest {
+
+ @Mock
+ private NodeTemplate nodeTemplate;
+
+ @Mock
+ private Group group;
+
+ @Mock
+ private Policy policy;
+
+
+ @Test
+ public void createNodeTemplateEntityDetailsWhenParentNodeIsNotNull() {
+ when(nodeTemplate.getParentNodeTemplate())
+ .thenReturn(nodeTemplate)
+ .thenReturn(null);
+ EntityDetails entityDetails = EntityDetailsFactory.createEntityDetails(EntityTemplateType.NODE_TEMPLATE, nodeTemplate);
+ assertTrue(entityDetails instanceof NodeTemplateEntityDetails);
+ assertTrue(entityDetails.getParent() instanceof NodeTemplateEntityDetails);
+ }
+
+ @Test
+ public void createNodeTemplateEntityDetailsWhenParentNodeIsNull() {
+ EntityDetails entityDetails = EntityDetailsFactory.createEntityDetails(EntityTemplateType.NODE_TEMPLATE, nodeTemplate);
+ assertTrue(entityDetails instanceof NodeTemplateEntityDetails);
+ assertEquals(null, entityDetails.getParent());
+ }
+
+ @Test
+ public void createNodeTemplateEntityDetailsWhenNnIsNull() {
+ assertEquals(null, EntityDetailsFactory.createEntityDetails(EntityTemplateType.NODE_TEMPLATE, null));
+ }
+
+ @Test
+ public void createGroupEntityDetailsWhenParentNodeIsNotNull() {
+ when(group.getParentNodeTemplate())
+ .thenReturn(nodeTemplate)
+ .thenReturn(null);
+ EntityDetails entityDetails = EntityDetailsFactory.createEntityDetails(EntityTemplateType.GROUP, group);
+ assertTrue(entityDetails instanceof GroupEntityDetails);
+ assertTrue(entityDetails.getParent() instanceof NodeTemplateEntityDetails);
+ }
+
+ @Test
+ public void createGroupEntityDetailsWhenParentNodeIsNull() {
+ EntityDetails entityDetails = EntityDetailsFactory.createEntityDetails(EntityTemplateType.GROUP, group);
+ assertTrue(entityDetails instanceof GroupEntityDetails);
+ assertEquals(null, entityDetails.getParent());
+ }
+
+ @Test
+ public void createGroupEntityDetailsWhenNnIsNull() {
+ assertEquals(null, EntityDetailsFactory.createEntityDetails(EntityTemplateType.GROUP, null));
+ }
+
+ @Test
+ public void createPolicyEntityDetailsWhenParentNodeIsNotNull() {
+ when(policy.getParentNodeTemplate())
+ .thenReturn(nodeTemplate)
+ .thenReturn(null);
+ EntityDetails entityDetails = EntityDetailsFactory.createEntityDetails(EntityTemplateType.POLICY, policy);
+ assertTrue(entityDetails instanceof PolicyEntityDetails);
+ assertTrue(entityDetails.getParent() instanceof NodeTemplateEntityDetails);
+ }
+
+ @Test
+ public void createPolicyEntityDetailsWhenParentNodeIsNull() {
+ EntityDetails entityDetails = EntityDetailsFactory.createEntityDetails(EntityTemplateType.POLICY, policy);
+ assertTrue(entityDetails instanceof PolicyEntityDetails);
+ assertEquals(null, entityDetails.getParent());
+ }
+
+ @Test
+ public void createPolicyEntityDetailsWhenNnIsNull() {
+ assertEquals(null, EntityDetailsFactory.createEntityDetails(EntityTemplateType.POLICY, null));
+ }
+
+ @Test(expected = ClassCastException.class)
+ public void createWrongEntityDetails() {
+ EntityDetailsFactory.createEntityDetails(EntityTemplateType.POLICY, group);
+ }
+
+
+ @Test
+ public void createEntityDetailsWhenTypeIsNull() {
+ assertEquals(null, EntityDetailsFactory.createEntityDetails(null, group));
+ }
+
+}
--- /dev/null
+package org.onap.sdc.tosca.parser.elements.queries;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.onap.sdc.tosca.parser.enums.EntityTemplateType;
+import org.onap.sdc.tosca.parser.impl.SdcPropertyNames;
+import org.onap.sdc.toscaparser.api.elements.Metadata;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class EntityQueryTest {
+ @Mock
+ private Metadata metadata;
+
+ @Test
+ public void findEntityWhenUuidAndCuudNotSetAndToscaTypeNotSet() {
+ EntityQuery entityQuery = EntityQuery.newBuilder(EntityTemplateType.GROUP)
+ .build();
+ when(metadata.getValue(eq(SdcPropertyNames.PROPERTY_NAME_UUID))).thenReturn("123");
+ when(metadata.getValue(eq(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID))).thenReturn("12345");
+ assertTrue(entityQuery.isSearchCriteriaMatched(metadata, ""));
+ }
+
+ @Test
+ public void findEntityWhenMetadataIsNull() {
+ EntityQuery entityQuery = EntityQuery.newBuilder(EntityTemplateType.GROUP)
+ .build();
+ assertFalse(entityQuery.isSearchCriteriaMatched(null,"abc"));
+ }
+
+ @Test
+ public void findEntityWhenMetadataIsNullAndUuidsAreProvided() {
+ EntityQuery entityQuery = EntityQuery.newBuilder(EntityTemplateType.NODE_TEMPLATE)
+ .customizationUUID("2345")
+ .uUID("9700")
+ .build();
+ assertFalse(entityQuery.isSearchCriteriaMatched(null, ""));
+ }
+
+ @Test
+ public void findEntityWhenUuidIsSetAndMatchedAndToscaTypeNotSet() {
+ EntityQuery entityQuery = EntityQuery.newBuilder(EntityTemplateType.GROUP)
+ .uUID("123")
+ .build();
+ when(metadata.getValue(eq(SdcPropertyNames.PROPERTY_NAME_UUID))).thenReturn("123");
+ when(metadata.getValue(eq(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID))).thenReturn("12345");
+
+ assertTrue(entityQuery.isSearchCriteriaMatched(metadata, "abc"));
+ }
+
+ @Test
+ public void findEntityWhenUuidIsSetAndMatchedAndCuuidIsNullAndToscaTypeNotSet() {
+ EntityQuery entityQuery = EntityQuery.newBuilder(EntityTemplateType.GROUP)
+ .uUID("123")
+ .build();
+ when(metadata.getValue(eq(SdcPropertyNames.PROPERTY_NAME_UUID))).thenReturn("123");
+ when(metadata.getValue(eq(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID))).thenReturn(null);
+
+ assertTrue(entityQuery.isSearchCriteriaMatched(metadata, ""));
+ }
+
+ @Test
+ public void findEntityWhenUuidAndCuuidAreSetAndMatchedAndCuuidIsNullAndToscaTypeNotSet() {
+ EntityQuery entityQuery = EntityQuery.newBuilder(EntityTemplateType.GROUP)
+ .uUID("123")
+ .customizationUUID("567")
+ .build();
+ when(metadata.getValue(eq(SdcPropertyNames.PROPERTY_NAME_UUID))).thenReturn("123");
+ when(metadata.getValue(eq(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID))).thenReturn(null);
+
+ assertFalse(entityQuery.isSearchCriteriaMatched(metadata, ""));
+ }
+
+
+ @Test
+ public void findEntityWhenUIDsAreSetAndMatchedAndToscaTypeNotSet() {
+ EntityQuery entityQuery = EntityQuery.newBuilder(EntityTemplateType.POLICY)
+ .uUID("123")
+ .customizationUUID("345")
+ .build();
+ when(metadata.getValue(eq(SdcPropertyNames.PROPERTY_NAME_UUID))).thenReturn("123");
+ when(metadata.getValue(eq(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID))).thenReturn("345");
+
+ assertTrue(entityQuery.isSearchCriteriaMatched(metadata, "qwe"));
+ }
+
+ @Test
+ public void findEntityWhenUIDsAreSetAndMatchedPartiallyAndToscaTypeNotSet() {
+ EntityQuery entityQuery = EntityQuery.newBuilder(EntityTemplateType.POLICY)
+ .uUID("123")
+ .customizationUUID("345")
+ .build();
+ when(metadata.getValue(eq(SdcPropertyNames.PROPERTY_NAME_UUID))).thenReturn("123");
+ when(metadata.getValue(eq(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID))).thenReturn("444");
+
+ assertFalse(entityQuery.isSearchCriteriaMatched(metadata, ""));
+ }
+
+ @Test
+ public void findEntityWhenUuidIsSetAndDoesNotMatchAndToscaTypeNotSet() {
+ EntityQuery entityQuery = EntityQuery.newBuilder(EntityTemplateType.GROUP)
+ .uUID("7890")
+ .build();
+ when(metadata.getValue(eq(SdcPropertyNames.PROPERTY_NAME_UUID))).thenReturn("123");
+ when(metadata.getValue(eq(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID))).thenReturn("12345");
+
+ assertFalse(entityQuery.isSearchCriteriaMatched(metadata, ""));
+ }
+
+ @Test
+ public void findEntityWhenUIDsAreSetAndMatchedAndToscaTypeIsNull() {
+ EntityQuery entityQuery = EntityQuery.newBuilder(EntityTemplateType.POLICY)
+ .uUID("123")
+ .customizationUUID("345")
+ .build();
+ when(metadata.getValue(eq(SdcPropertyNames.PROPERTY_NAME_UUID))).thenReturn("123");
+ when(metadata.getValue(eq(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID))).thenReturn("345");
+
+ assertTrue(entityQuery.isSearchCriteriaMatched(metadata, null));
+ }
+
+ @Test
+ public void findEntityWhenUIDsAreSetAndMatchedAndToscaTypeIsNotMatched() {
+ EntityQuery entityQuery = EntityQuery.newBuilder("a.policies.b")
+ .uUID("123")
+ .customizationUUID("345")
+ .build();
+ when(metadata.getValue(eq(SdcPropertyNames.PROPERTY_NAME_UUID))).thenReturn("123");
+ when(metadata.getValue(eq(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID))).thenReturn("345");
+
+ assertFalse(entityQuery.isSearchCriteriaMatched(metadata, "abc"));
+ }
+
+ @Test
+ public void findEntityWhenUIDsAreSetAndMatchedAndToscaTypeIsMatched() {
+ EntityQuery entityQuery = EntityQuery.newBuilder("a.groups.b")
+ .uUID("123")
+ .customizationUUID("345")
+ .build();
+ when(metadata.getValue(eq(SdcPropertyNames.PROPERTY_NAME_UUID))).thenReturn("123");
+ when(metadata.getValue(eq(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID))).thenReturn("345");
+
+ assertTrue(entityQuery.isSearchCriteriaMatched(metadata, "a.groups.b"));
+ }
+
+ @Test
+ public void findEntityWhenUIDsAreNotMatchedAndToscaTypeIsMatched() {
+ EntityQuery entityQuery = EntityQuery.newBuilder("a.groups.b")
+ .uUID("123")
+ .customizationUUID("345")
+ .build();
+ when(metadata.getValue(eq(SdcPropertyNames.PROPERTY_NAME_UUID))).thenReturn("12345");
+ when(metadata.getValue(eq(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID))).thenReturn("3456");
+
+ assertFalse(entityQuery.isSearchCriteriaMatched(metadata, "a.groups.b"));
+ }
+}
--- /dev/null
+package org.onap.sdc.tosca.parser.elements.queries;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.onap.sdc.tosca.parser.enums.SdcTypes;
+import org.onap.sdc.tosca.parser.impl.SdcPropertyNames;
+import org.onap.sdc.toscaparser.api.NodeTemplate;
+import org.onap.sdc.toscaparser.api.elements.Metadata;
+
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.when;
+import static org.testng.Assert.assertFalse;
+
+@RunWith(MockitoJUnitRunner.class)
+public class TopologyTemplateQueryTest {
+
+ @Mock
+ private Metadata metadata;
+
+ @Mock
+ private NodeTemplate nodeTemplate;
+
+ @Test(expected=IllegalArgumentException.class)
+ public void objectIsNotTopologyTemplate() {
+ TopologyTemplateQuery.newBuilder(SdcTypes.CP)
+ .build();
+ }
+
+ @Test
+ public void templateIsFoundByTypeOnly() {
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.SERVICE)
+ .build();
+ when(nodeTemplate.getMetaData()).thenReturn(metadata);
+ when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID)).thenReturn("345");
+ when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)).thenReturn(SdcTypes.SERVICE.getValue());
+ assertTrue(topologyTemplateQuery.isMatchingSearchCriteria(nodeTemplate));
+ }
+
+ @Test
+ public void templateIsNotFoundWhenMetadataIsNull() {
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.VF)
+ .build();
+ when(nodeTemplate.getMetaData()).thenReturn(null);
+ assertFalse(topologyTemplateQuery.isMatchingSearchCriteria(nodeTemplate));
+ }
+
+ @Test
+ public void templateIsFoundIfItIsService() {
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.SERVICE)
+ .build();
+ when(nodeTemplate.getMetaData()).thenReturn(metadata);
+ when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)).thenReturn(SdcTypes.SERVICE.getValue());
+ assertTrue(topologyTemplateQuery.isMatchingSearchCriteria(nodeTemplate));
+ }
+
+ @Test
+ public void templateIsFoundByTypeAndCUUID() {
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.CVFC)
+ .customizationUUID("345")
+ .build();
+ when(nodeTemplate.getMetaData()).thenReturn(metadata);
+ when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)).thenReturn(SdcTypes.CVFC.getValue());
+ when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID)).thenReturn("345");
+ assertTrue(topologyTemplateQuery.isMatchingSearchCriteria(nodeTemplate));
+ }
+
+ @Test
+ public void templateIsNotFoundWhenTypeIsNotMatchedAndCuuidIsNotSet() {
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.CVFC)
+ .build();
+ when(nodeTemplate.getMetaData()).thenReturn(metadata);
+ when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)).thenReturn(SdcTypes.VF.getValue());
+ assertFalse(topologyTemplateQuery.isMatchingSearchCriteria(nodeTemplate));
+ }
+
+ @Test
+ public void templateIsFoundWhenTypeIsMatchedCuuidIsProvidedAndCuuidIsNullInMetadata() {
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.VF)
+ .customizationUUID("2345")
+ .build();
+ when(nodeTemplate.getMetaData()).thenReturn(metadata);
+ when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID)).thenReturn(null);
+ when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)).thenReturn(SdcTypes.VF.getValue());
+ assertFalse(topologyTemplateQuery.isMatchingSearchCriteria(nodeTemplate));
+ }
+
+ @Test
+ public void templateIsFoundWhenTypeIsMatchedAndCuuidIsNullInMetadata() {
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.VF)
+ .build();
+ when(nodeTemplate.getMetaData()).thenReturn(metadata);
+ when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID)).thenReturn(null);
+ when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)).thenReturn(SdcTypes.VF.getValue());
+ assertTrue(topologyTemplateQuery.isMatchingSearchCriteria(nodeTemplate));
+ }
+
+ @Test
+ public void templateIsNotFoundWhenTypeIsMatchedAndCuuidIsSet() {
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.CVFC)
+ .customizationUUID("345")
+ .build();
+ when(nodeTemplate.getMetaData()).thenReturn(metadata);
+ when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)).thenReturn(SdcTypes.CVFC.getValue());
+ when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID)).thenReturn("345");
+ assertTrue(topologyTemplateQuery.isMatchingSearchCriteria(nodeTemplate));
+ }
+
+ @Test
+ public void templateIsNotFoundWhenTypeIsNotMatchedAndCuuidIsSet() {
+ TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.CR)
+ .customizationUUID("345")
+ .build();
+ when(nodeTemplate.getMetaData()).thenReturn(metadata);
+ when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)).thenReturn(SdcTypes.CVFC.getValue());
+ when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID)).thenReturn("345");
+ assertFalse(topologyTemplateQuery.isMatchingSearchCriteria(nodeTemplate));
+ }
+
+
+}
major=1
minor=4
-patch=9
+patch=10
base_version=${major}.${minor}.${patch}
Code Review / sdc / sdc-tosca.git / commitdiff