<parent>
<groupId>org.openecomp.sdc.sdc-distribution-client</groupId>
<artifactId>sdc-main-distribution-client</artifactId>
- <version>1.1.0-SNAPSHOT</version>
+ <version>1.1.6-SNAPSHOT</version>
</parent>
<artifactId>jython-tosca-parser</artifactId>
import static com.google.common.collect.ImmutableList.toImmutableList;
+import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import org.openecomp.sdc.toscaparser.api.elements.StatefulEntityType;
+import org.openecomp.sdc.toscaparser.jython.JyCapability;
import org.openecomp.sdc.toscaparser.jython.JyEntityTemplate;
+import org.openecomp.sdc.toscaparser.jython.JyProperty;
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
}
public List<Property> getProperties() {
- return jyEntityTemplate.getJyProperties()
+ List<JyProperty> jyProperties = jyEntityTemplate.getJyProperties();
+ return jyProperties != null ? jyProperties
.stream()
.map(Property::new)
- .collect(toImmutableList());
+ .collect(toImmutableList()) : new ArrayList<>();
}
public List<Capability> getCapabilities() {
- return jyEntityTemplate.getJyCapabilities()
+ List<JyCapability> jyCapabilities = jyEntityTemplate.getJyCapabilities();
+ return jyCapabilities != null ? jyCapabilities
.stream()
.map(Capability::new)
- .collect(toImmutableList());
+ .collect(toImmutableList()) : new ArrayList<>();
}
public List<Map<String, Map<String, Object>>> getRequirements() {
package org.openecomp.sdc.toscaparser.api;
+import java.util.List;
+
import org.openecomp.sdc.toscaparser.jython.JyGroup;
+import com.google.common.base.MoreObjects.ToStringHelper;
+
public class Group extends EntityTemplate {
+ private final JyGroup jyGroup;
+
public Group(JyGroup jyGroup) {
super(jyGroup);
+ this.jyGroup = jyGroup;
+ }
+
+ public List<String> getMembers(){
+ return jyGroup.getJyMembers();
}
+
+ public Metadata getMetadata(){
+ return jyGroup.getJyMetadata() != null ? new Metadata(jyGroup.getJyMetadata()) : null;
+ }
+
+ @Override
+ protected ToStringHelper toStringHelper() {
+ return super.toStringHelper()
+ .add("members", getMembers())
+ .add("metadata", getMetadata());
+ }
}
--- /dev/null
+package org.openecomp.sdc.toscaparser.api;\r
+\r
+import java.util.Map;\r
+\r
+import com.google.common.base.MoreObjects;\r
+\r
+public class Metadata {\r
+ \r
+ private final Map<String, Object> metadataMap;\r
+\r
+ public Metadata(Map<String, Object> metadataMap) {\r
+ this.metadataMap = metadataMap;\r
+ }\r
+ \r
+ public String getValue(String key) {\r
+ return !isEmpty() ? String.valueOf(this.metadataMap.get(key)) : null;\r
+ }\r
+\r
+ private boolean isEmpty() {\r
+ return this.metadataMap == null || this.metadataMap.size() == 0;\r
+ }\r
+\r
+ @Override\r
+ public String toString() {\r
+ return MoreObjects.toStringHelper(this)\r
+ .add("metadataMap", metadataMap).toString();\r
+ }\r
+}\r
package org.openecomp.sdc.toscaparser.api;
-import java.util.Map;
-
import org.openecomp.sdc.toscaparser.jython.JyNodeTemplate;
+import org.openecomp.sdc.toscaparser.jython.JySubstitutionMappings;
import com.google.common.base.MoreObjects.ToStringHelper;
this.jyNodeTemplate = jyNodeTemplate;
}
- public Map<String, String> getMetadata() {
- return jyNodeTemplate.getJyMetadata();
+ public Metadata getMetadata() {
+ return jyNodeTemplate.getJyMetadata() != null ? new Metadata(jyNodeTemplate.getJyMetadata()) : null;
+ }
+
+ public SubstitutionMappings getSubstitutionMappings(){
+ JySubstitutionMappings jySubstitutionMappings = jyNodeTemplate.getJySubstitutionMappings();
+ return jySubstitutionMappings != null ? new SubstitutionMappings(jySubstitutionMappings) : null;
}
@Override
protected ToStringHelper toStringHelper() {
return super.toStringHelper()
- .add("metadata", getMetadata());
+ .add("metadata", getMetadata())
+ .add("substitutionMappings", getSubstitutionMappings());
}
}
import static com.google.common.collect.ImmutableList.toImmutableList;
+import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import org.openecomp.sdc.toscaparser.api.elements.NodeType;
import org.openecomp.sdc.toscaparser.api.parameters.Input;
+import org.openecomp.sdc.toscaparser.jython.JyGroup;
import org.openecomp.sdc.toscaparser.jython.JySubstitutionMappings;
+import org.openecomp.sdc.toscaparser.jython.parameters.JyInput;
import com.google.common.base.MoreObjects;
.map(NodeTemplate::new)
.collect(toImmutableList());
}
+
+ public List<Group> getGroups() {
+ List<JyGroup> jyGroups = jySubstitutionMappings.getJyGroups();
+ return jyGroups != null ? jyGroups
+ .stream()
+ .map(Group::new)
+ .collect(toImmutableList()) : new ArrayList<>();
+ }
public List<Input> getInputs() {
- return jySubstitutionMappings.getJyInputs()
+ List<JyInput> jyInputs = jySubstitutionMappings.getJyInputs();
+ return jyInputs != null ? jyInputs
.stream()
.map(Input::new)
- .collect(toImmutableList());
+ .collect(toImmutableList()) : new ArrayList<>();
}
public NodeType getNodeDefinition() {
import static com.google.common.collect.ImmutableList.toImmutableList;
+import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import org.openecomp.sdc.toscaparser.api.parameters.Input;
+import org.openecomp.sdc.toscaparser.jython.JyGroup;
+import org.openecomp.sdc.toscaparser.jython.JyNodeTemplate;
import org.openecomp.sdc.toscaparser.jython.JySubstitutionMappings;
import org.openecomp.sdc.toscaparser.jython.JyTopologyTemplate;
+import org.openecomp.sdc.toscaparser.jython.parameters.JyInput;
import com.google.common.base.MoreObjects;
}
public List<NodeTemplate> getNodeTemplates() {
- return jyTopologyTemplate.getJyNodeTemplates()
+ List<JyNodeTemplate> jyNodeTemplates = jyTopologyTemplate.getJyNodeTemplates();
+ return jyNodeTemplates != null ? jyNodeTemplates
.stream()
.map(NodeTemplate::new)
- .collect(toImmutableList());
+ .collect(toImmutableList()) : new ArrayList<>();
}
public List<Input> getInputs() {
- return jyTopologyTemplate.getJyInputs()
+ List<JyInput> jyInputs = jyTopologyTemplate.getJyInputs();
+ return jyInputs != null ? jyInputs
.stream()
.map(Input::new)
- .collect(toImmutableList());
+ .collect(toImmutableList()) : new ArrayList<>();
}
public List<Group> getGroups() {
- return jyTopologyTemplate.getJyGroups()
+ List<JyGroup> jyGroups = jyTopologyTemplate.getJyGroups();
+ return jyGroups != null ? jyGroups
.stream()
.map(Group::new)
- .collect(toImmutableList());
+ .collect(toImmutableList()) : new ArrayList<>();
}
public SubstitutionMappings getSubstitutionMappings() {
return jySubstitutionMappings != null ? new SubstitutionMappings(jySubstitutionMappings) : null;
}
- public Map<String, String> getMetadata() {
+ public Metadata getMetadata() {
return jyTopologyTemplate.getJyMetadata();
}
public String getVersion() {
return jyToscaTemplate.getJyVersion();
}
+
+ public Metadata getMetadata() {
+ return jyToscaTemplate.getJyMetadata() != null ? new Metadata(jyToscaTemplate.getJyMetadata()) : null;
+ }
public String getDescription() {
return jyToscaTemplate.getJyDescription();
}
public List<TopologyTemplate> getNestedTopologyTemplates() {
- return jyToscaTemplate.getNestedTopologyTemplates()
+ return jyToscaTemplate.getJyNestedTopologyTemplates()
.stream()
.map(TopologyTemplate::new)
.collect(toImmutableList());
.add("version", getVersion())
.add("description", getDescription())
.add("topologyTemplate", topologyTemplate)
+ .add("nestedTopologyTemplates", getNestedTopologyTemplates())
.toString();
}
}
\ No newline at end of file
return jyInput.getJyType();
}
-
-
public boolean isRequired() {
return jyInput.isJyRequired();
}
public String getDescription() {
return jyInput.getJyDescription();
}
+
+ public Object getDefault() {
+ return jyInput.getJyDefault();
+ }
@Override
public String toString() {
.add("type", getType())
.add("required", isRequired())
.add("description", getDescription())
+ .add("default", getDefault())
.toString();
}
}
package org.openecomp.sdc.toscaparser.jython;
-public interface JyGroup extends JyEntityTemplate {
+import java.util.List;
+import java.util.Map;
+public interface JyGroup extends JyEntityTemplate {
+
+ List<String> getJyMembers();
+ Map<String, Object> getJyMetadata();
}
public interface JyNodeTemplate extends JyEntityTemplate {
- Map<String, String> getJyMetadata();
+ Map<String, Object> getJyMetadata();
+ JySubstitutionMappings getJySubstitutionMappings();
}
List<JyNodeTemplate> getJyNodeTemplates();
List<JyInput> getJyInputs();
+ List<JyGroup> getJyGroups();
JyNodeType getJyNodeDefinition();
}
package org.openecomp.sdc.toscaparser.jython;
import java.util.List;
-import java.util.Map;
+import org.openecomp.sdc.toscaparser.api.Metadata;
import org.openecomp.sdc.toscaparser.jython.parameters.JyInput;
public interface JyTopologyTemplate {
List<JyInput> getJyInputs();
List<JyGroup> getJyGroups();
JySubstitutionMappings getJySubstitutionMappings();
- Map<String, String> getJyMetadata();
+ Metadata getJyMetadata();
}
package org.openecomp.sdc.toscaparser.jython;
import java.util.List;
+import java.util.Map;
public interface JyToscaTemplate {
String getJyVersion();
String getJyDescription();
List<JyNodeTemplate> getJyNodeTemplates();
- List<JyTopologyTemplate> getNestedTopologyTemplates();
+ List<JyTopologyTemplate> getJyNestedTopologyTemplates();
JyTopologyTemplate getJyTopologyTemplate();
+ Map<String, Object> getJyMetadata();
}
String getJyName();
String getJyType();
- String getJyDefault();
+ Object getJyDefault();
boolean isJyRequired();
String getJyDescription();
}
self.member_nodes = member_nodes
self._validate_keys()
+ def getJyMembers(self):
+ return self.members
+
+ def getJyMetadata(self):
+ return self.meta_data
+
@property
def members(self):
return self.entity_tpl.get('members')
def getJyMetadata(self):
return self.meta_data
+ def getJySubstitutionMappings(self):
+ return self.sub_mapping_tosca_template
+
+
@property
def relationships(self):
if not self._relationships:
return self.name
def getJyType(self):
- return self.name
+ return self.type
def isJyRequired(self):
return self.required
def validate_type(self, input_type):
if input_type not in Schema.PROPERTY_TYPES:
ExceptionCollector.appendException(
- ValueError(_('Invalid type "%s".') % type))
+ #ValueError(_('Invalid type "%s".') % type))
+ ValueError(_('Invalid type "%s".') % input_type))
# TODO(anyone) Need to test for any built-in datatype not just network
# that is, tosca.datatypes.* and not assume tosca.datatypes.network.*
OPTIONAL_OUTPUTS = ['tosca_id', 'tosca_name', 'state']
- def __init__(self, sub_mapping_def, nodetemplates, inputs, outputs,
+ def __init__(self, sub_mapping_def, nodetemplates, inputs, outputs, groups, #ATT
sub_mapped_node_template, custom_defs):
self.nodetemplates = nodetemplates
self.sub_mapping_def = sub_mapping_def
self.inputs = inputs or []
self.outputs = outputs or []
+ self.groups = groups or [] #ATT
self.sub_mapped_node_template = sub_mapped_node_template
self.custom_defs = custom_defs or {}
self._validate()
def getJyInputs(self):
return self.inputs
+ def getJyGroups(self): #ATT
+ return self.groups
+
def getJyNodeDefinition(self):
return self.node_definition
self.nodetemplates,
self.inputs,
self.outputs,
+ self.groups, #ATT
self.sub_mapped_node_template,
self.custom_defs)
import logging
import os
+#import shutil
from copy import deepcopy
from toscaparser.common.exception import ExceptionCollector
self.input_path = None
self.path = None
self.tpl = None
+ self.csar_tempdir = None
self.nested_tosca_tpls_with_topology = {}
self.nested_tosca_templates_with_topology = []
if path:
self.parsed_params = parsed_params
self._validate_field()
self.version = self._tpl_version()
+ self.metadata = self._tpl_metadata()
self.relationship_types = self._tpl_relationship_types()
self.description = self._tpl_description()
self.topology_template = self._topology_template()
self._handle_nested_tosca_templates_with_topology()
self.graph = ToscaGraph(self.nodetemplates)
+ if self.csar_tempdir:
+ #shutil.rmtree(self.csar_tempdir)
+ csar_tempdir = None
+
ExceptionCollector.stop()
self.verify_template()
def getJyVersion(self):
return self.version
+ def getJyMetadata(self):
+ return self.metadata
+
def getJyDescription(self):
return self.description
def _tpl_version(self):
return self.tpl.get(DEFINITION_VERSION)
+ def _tpl_metadata(self):
+ return self.tpl.get(METADATA)
+
def _tpl_description(self):
desc = self.tpl.get(DESCRIPTION)
if desc:
if csar.validate():
csar.decompress()
self.a_file = True # the file has been decompressed locally
+ self.csar_tempdir = csar.temp_dir
return os.path.join(csar.temp_dir, csar.get_main_template())
else:
ExceptionCollector.appendException(
<groupId>org.openecomp.sdc.sdc-distribution-client</groupId>
<artifactId>sdc-main-distribution-client</artifactId>
- <version>1.1.0-SNAPSHOT</version>
+ <version>1.1.6-SNAPSHOT</version>
<packaging>pom</packaging>
<modules>
<parent>
<groupId>org.openecomp.sdc.sdc-distribution-client</groupId>
<artifactId>sdc-main-distribution-client</artifactId>
- <version>1.1.0-SNAPSHOT</version>
+ <version>1.1.6-SNAPSHOT</version>
</parent>
<artifactId>sdc-distribution-ci</artifactId>
public class ClientTest {
public static void main(String[] args) throws Exception {
- try (SdcToscaParserFactory toscaParserFactory = SdcToscaParserFactory.getInstance()){
- //ISdcCsarHelper csarHelper = toscaParserFactory.getSdcCsarHelper("C:\\Users\\pa0916\\Desktop\\Work\\ASDC\\CSARs\\service-ServiceFdnt-csar-nt-metadata.csar");
- ISdcCsarHelper csarHelper = toscaParserFactory.getSdcCsarHelper("C:\\Users\\pa0916\\Desktop\\Work\\ASDC\\CSARs\\service-ServiceFdnt-csar-nt-props.csar");
- //ISdcCsarHelper csarHelper = toscaParserFactory.getSdcCsarHelper("C:\\Users\\pa0916\\Desktop\\Work\\ASDC\\CSARs\\service-ServiceFdnt-csar.csar");
- String serviceSubstitutionMappingsTypeName = csarHelper.getServiceSubstitutionMappingsTypeName();
- System.out.println("serviceSubstitutionMappingsTypeName is "+serviceSubstitutionMappingsTypeName);
- String nodeTemplatePropertyLeafValue = csarHelper.getNodeTemplatePropertyLeafValue(csarHelper.getServiceVfList().get(0), "nf_role#nf_naming#ecomp_generated_naming");
- System.out.println("property is "+nodeTemplatePropertyLeafValue);
- }
+
LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
lc.getLogger("org.apache.http").setLevel(Level.INFO);
<parent>
<groupId>org.openecomp.sdc.sdc-distribution-client</groupId>
<artifactId>sdc-main-distribution-client</artifactId>
- <version>1.1.0-SNAPSHOT</version>
+ <version>1.1.6-SNAPSHOT</version>
</parent>
<artifactId>sdc-distribution-client</artifactId>
<parent>\r
<groupId>org.openecomp.sdc.sdc-distribution-client</groupId>\r
<artifactId>sdc-main-distribution-client</artifactId>\r
- <version>1.1.0-SNAPSHOT</version>\r
+ <version>1.1.6-SNAPSHOT</version>\r
</parent>\r
\r
<artifactId>sdc-tosca-parser</artifactId>\r
import java.util.List;
-import java.util.Map;
import org.apache.commons.lang3.tuple.Pair;
import org.openecomp.sdc.toscaparser.api.Group;
+import org.openecomp.sdc.toscaparser.api.Metadata;
import org.openecomp.sdc.toscaparser.api.NodeTemplate;
+import org.openecomp.sdc.toscaparser.api.parameters.Input;
public interface ISdcCsarHelper {
* @param metadata - metadata object.
* @param metadataPropertyName - the name of the metadata property.
* @return metadata property value
- *//*
- //public String getMetadataPropertyValue(Metadata metadata, String metadataPropertyName);
- */
+ */
+ public String getMetadataPropertyValue(Metadata metadata, String metadataPropertyName);
+
/**
* Get input leaf value for the CSAR service, by full path separated by #.<br>
* Same logic as in {@link #getNodeTemplatePropertyLeafValue(NodeTemplate, String) getNodeTemplatePropertyLeafValue}, only for an input full path.
+ * The expected format is "input_name#default[optionally #rest_of_path]"
* @param inputLeafValuePath by full path separated by #.
* @return input leaf value for the service.
*/
- public String getServiceInputLeafValue(String inputLeafValuePath);
+ public String getServiceInputLeafValueOfDefault(String inputLeafValuePath);
/**
* Get the type name of the CSAR service's substitution mappings element.<br>
* Get the CSAR service metadata
* @return - the service metadata object.
*/
- public Map<String, String> getServiceMetadata();
+ public Metadata getServiceMetadata();
/**
* Get all VFC node templates from a specified VF.
members: [vIPR_ATM_Ha_Two, vIPR_ATM_Ha_One, vIPR_ATM_OAM_SG, vIPR_ATM_HA_TWO_SG, vIPR_ATM_HA_ONE_SG]<br><br>
calling<br>
- getMembersOfGroup(group)<br>
- will return List of the following Strings: "vIPR_ATM_Ha_Two, vIPR_ATM_Ha_One, vIPR_ATM_OAM_SG, vIPR_ATM_HA_TWO_SG, vIPR_ATM_HA_ONE_SG"<br>
- * @param group - group to return the members.
- * @return names of all group members.
+ getMembersOfVfModule(NoteTemplate vfNodeTemplate, Group group)<br>
+ will return List of the following Node templates in the vfNodeTemplate: "vIPR_ATM_Ha_Two, vIPR_ATM_Ha_One, vIPR_ATM_OAM_SG, vIPR_ATM_HA_TWO_SG, vIPR_ATM_HA_ONE_SG"<br>
+ * @param vf - VF to return the node templates from.
+ * @param vfModule - group to return the members from.
+ * @return node templates from vf with the names as in members section.
*
*/
- public List<String> getMembersOfGroup(Group group);
+ public List<NodeTemplate> getMembersOfVfModule(NodeTemplate vf, Group vfModule);
/**
*/
public String getTypeOfNodeTemplate(NodeTemplate nodeTemplate);
+ /**
+ * Get the CSAR service inputs list.
+ * @return - the service inputs list.
+ */
+ public List<Input> getServiceInputs();
+
}
package org.openecomp.sdc.tosca.parser.impl;
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.apache.commons.lang3.tuple.Pair;
+import org.openecomp.sdc.tosca.parser.api.ISdcCsarHelper;
+import org.openecomp.sdc.tosca.parser.utils.GeneralUtility;
+import org.openecomp.sdc.toscaparser.api.*;
+import org.openecomp.sdc.toscaparser.api.elements.NodeType;
+import org.openecomp.sdc.toscaparser.api.parameters.Input;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.yaml.snakeyaml.Yaml;
+
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
-import java.util.stream.Collector;
import java.util.stream.Collectors;
-import org.apache.commons.lang3.tuple.Pair;
-import org.openecomp.sdc.tosca.parser.api.ISdcCsarHelper;
-import org.openecomp.sdc.toscaparser.api.Group;
-import org.openecomp.sdc.toscaparser.api.NodeTemplate;
-import org.openecomp.sdc.toscaparser.api.Property;
-import org.openecomp.sdc.toscaparser.api.TopologyTemplate;
-import org.openecomp.sdc.toscaparser.api.ToscaTemplate;
-import org.yaml.snakeyaml.Yaml;
-
public class SdcCsarHelperImpl implements ISdcCsarHelper {
private ToscaTemplate toscaTemplate;
- private static Yaml defaultYaml = new Yaml();
-
+ private static Logger log = LoggerFactory.getLogger(SdcCsarHelperImpl.class.getName());
public SdcCsarHelperImpl(ToscaTemplate toscaTemplate) {
this.toscaTemplate = toscaTemplate;
@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;
+ }
+ log.trace("getNodeTemplatePropertyLeafValue - nodeTemplate is : {}, leafValuePath is {} ", nodeTemplate.toString(), leafValuePath);
String[] split = leafValuePath.split("#");
List<Property> properties = nodeTemplate.getProperties();
- Optional<Property> findFirst = properties.stream().filter(x -> x.getName().equals(split[0])).findFirst();
- if (findFirst.isPresent()){
- Property property = findFirst.get();
- Object current = property.getValue();
- if (split.length > 1){
- current = defaultYaml.load((String)current);
- for (int i = 1; i < split.length; i++) {
- current = ((Map<String, Object>)current).get(split[i]);
- }
- }
- return String.valueOf(current);
- }
- return null;
+ log.trace("getNodeTemplatePropertyLeafValue - properties of nodeTemplate are : {}", properties.toString());
+ return processProperties(split, properties);
}
@Override
+ //Sunny flow - covered with UT
public List<NodeTemplate> getServiceVlList() {
- return getNodeTemplateBySdcType(toscaTemplate.getTopologyTemplate(), Types.TYPE_VL);
-
+ List<NodeTemplate> serviceVlList = getNodeTemplateBySdcType(toscaTemplate.getTopologyTemplate(), Types.TYPE_VL);
+ log.trace("getServiceVlList - the VL list is {}", serviceVlList);
+ return serviceVlList;
}
@Override
//Sunny flow - covered with UT
public List<NodeTemplate> getServiceVfList() {
- return getNodeTemplateBySdcType(toscaTemplate.getTopologyTemplate(), Types.TYPE_VF);
+ List<NodeTemplate> serviceVfList = getNodeTemplateBySdcType(toscaTemplate.getTopologyTemplate(), Types.TYPE_VF);
+ log.trace("getServiceVfList - the VF list is {}", serviceVfList);
+ return serviceVfList;
+ }
+
+ @Override
+ //Sunny flow - covered with UT
+ public String getMetadataPropertyValue(Metadata metadata, String metadataPropertyName) {
+ if (GeneralUtility.isEmptyString(metadataPropertyName)) {
+ log.error("getMetadataPropertyValue - the metadataPropertyName is null or empty");
+ return null;
+ }
+ if (metadata == null) {
+ log.error("getMetadataPropertyValue - the metadata is null");
+ return null;
+ }
+ String metadataPropertyValue = metadata.getValue(metadataPropertyName);
+ log.trace("getMetadataPropertyValue - metadata is {} metadataPropertyName is {} the value is : {}", metadata.toString(), metadataPropertyName , metadataPropertyValue);
+ return metadataPropertyValue;
}
+
@Override
//Sunny flow - covered with UT
public List<NodeTemplate> getServiceNodeTemplatesByType(String nodeType) {
+ if (GeneralUtility.isEmptyString(nodeType)) {
+ log.error("getServiceNodeTemplatesByType - nodeType - is null or empty");
+ return new ArrayList<>();
+ }
+
List<NodeTemplate> res = new ArrayList<>();
List<NodeTemplate> nodeTemplates = toscaTemplate.getNodeTemplates();
for (NodeTemplate nodeTemplate : nodeTemplates){
res.add(nodeTemplate);
}
}
+
+ log.trace("getServiceNodeTemplatesByType - NodeTemplate list value is: {}", res);
return res;
}
@Override
+ //Sunny flow - covered with UT
public List<NodeTemplate> getVfcListByVf(String vfCustomizationId) {
+ if (GeneralUtility.isEmptyString(vfCustomizationId)) {
+ log.error("getVfcListByVf - vfCustomizationId - is null or empty");
+ return new ArrayList<>();
+ }
+
List<NodeTemplate> serviceVfList = getServiceVfList();
NodeTemplate vfInstance = getNodeTemplateByCustomizationUuid(serviceVfList, vfCustomizationId);
+ log.trace("getVfcListByVf - serviceVfList value: {}, vfInstance value: {}", serviceVfList, vfInstance);
return getNodeTemplateBySdcType(vfInstance, Types.TYPE_VFC);
}
- //Assumed to be unique property for the list
- private NodeTemplate getNodeTemplateByCustomizationUuid(List<NodeTemplate> nodeTemplates, String customizationId){
- for (NodeTemplate nodeTemplate : nodeTemplates){
- if (customizationId.equals(nodeTemplate.getMetadata().get(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID))){
- return nodeTemplate;
- }
- }
- return null;
- }
-
@Override
+ //Sunny flow - covered with UT
public List<Group> getVfModulesByVf(String vfCustomizationUuid) {
List<NodeTemplate> serviceVfList = getServiceVfList();
- List<Group> res = new ArrayList<>();
NodeTemplate nodeTemplateByCustomizationUuid = getNodeTemplateByCustomizationUuid(serviceVfList, vfCustomizationUuid);
- //Asked Yaniv about getGroups from NodeTemplate
- /*
- List<Group> groups = nodeTemplateByCustomizationUuid.;
- for (Group group : groups){
- if (Types.TYPE_VFMODULE.equals(group.getType())){
- res.add(group);
+ if (nodeTemplateByCustomizationUuid != null){
+ SubstitutionMappings substitutionMappings = nodeTemplateByCustomizationUuid.getSubstitutionMappings();
+ if (substitutionMappings != null){
+ List<Group> groups = substitutionMappings.getGroups();
+ if (groups != null){
+ return groups.stream().filter(x -> "org.openecomp.groups.VfModule".equals(x.getTypeDefinition().getType())).collect(Collectors.toList());
+ }
}
- }*/
- return res;
+ }
+ return new ArrayList<>();
}
@Override
- public String getServiceInputLeafValue(String inputLeafValuePath) {
- //toscaTemplate.getTopologyTemplate().getNodeTemplates().get(0).getProperties().get(0).
- return null;//getLeafPropertyValue(toscaTemplate, inputLeafValuePath);
+ //Sunny flow - covered with UT
+ public String getServiceInputLeafValueOfDefault(String inputLeafValuePath) {
+ if (GeneralUtility.isEmptyString(inputLeafValuePath)) {
+ log.error("getServiceInputLeafValueOfDefault - inputLeafValuePath is null or empty");
+ return null;
+ }
+
+ String[] split = inputLeafValuePath.split("#");
+ if (split.length < 2 || !split[1].equals("default")){
+ log.error("getServiceInputLeafValue - inputLeafValuePath should be of format <input name>#default[optionally #<rest of path>] ");
+ return null;
+ }
+
+ List<Input> inputs = toscaTemplate.getInputs();
+ log.trace("getServiceInputLeafValue - the leafValuePath is {} , the inputs are {}", inputLeafValuePath, inputs);
+ if (inputs != null){
+ Optional<Input> findFirst = inputs.stream().filter(x -> x.getName().equals(split[0])).findFirst();
+ if (findFirst.isPresent()){
+ log.trace("getServiceInputLeafValue - find first item is {}", findFirst.get().toString());
+ Input input = findFirst.get();
+ Object current = input.getDefault();
+ if (current == null){
+ log.error("getServiceInputLeafValue - this input has no default");
+ return null;
+ }
+ if (split.length > 2){
+ current = new Yaml().load((String)current);
+ for (int i = 2; i < split.length; i++) {
+ if (current instanceof Map){
+ current = ((Map<String, Object>)current).get(split[i]);
+ } else {
+ log.error("getServiceInputLeafValue - found an unexpected leaf where expected to find a complex type");
+ return null;
+ }
+ }
+ }
+ if (current != null){
+ log.trace("getServiceInputLeafValue - the input default leaf value is {}", String.valueOf(current));
+ return String.valueOf(current);
+ }
+ }
+ }
+ log.error("getServiceInputLeafValue - value not found");
+ return null;
}
+
@Override
+ //Sunny flow - covered with UT
public String getServiceSubstitutionMappingsTypeName() {
- return toscaTemplate.getTopologyTemplate().getSubstitutionMappings().getNodeDefinition().getType();
- }
+ SubstitutionMappings substitutionMappings = toscaTemplate.getTopologyTemplate().getSubstitutionMappings();
+ if (substitutionMappings == null) {
+ log.trace("getServiceSubstitutionMappingsTypeName - No Substitution Mappings defined");
+ return null;
+ }
+ log.trace("getServiceSubstitutionMappingsTypeName - SubstitutionMappings value: {}", substitutionMappings);
- @Override
- public Map<String, String> getServiceMetadata() {
- TopologyTemplate topologyTemplate = toscaTemplate.getTopologyTemplate();
- System.out.println(topologyTemplate.toString());
- return topologyTemplate.getMetadata();
+ NodeType nodeType = substitutionMappings.getNodeDefinition();
+ if (nodeType == null) {
+ log.trace("getServiceSubstitutionMappingsTypeName - No Substitution Mappings node defined");
+ return null;
+ }
+ log.trace("getServiceSubstitutionMappingsTypeName - nodeType value: {}", nodeType);
+
+ return nodeType.getType();
}
- //Get property from group
@Override
- public String getGroupPropertyLeafValue(Group group, String propertyName) {
- return null;//getLeafPropertyValue(group, propertyName);
+ //Sunny flow - covered with UT
+ public Metadata getServiceMetadata() {
+ return toscaTemplate.getMetadata();
}
- private List<NodeTemplate> getNodeTemplateBySdcType(NodeTemplate nodeTemplate, String sdcType){
- //Need metadata to fetch by type
-
- /*List<NodeTemplate> nodeTemplates = nodeTemplate.getNestedNodeTemplates();
- List<NodeTemplate> res = new ArrayList<>();
- for (NodeTemplate nodeTemplateEntry : nodeTemplates){
- if (nodeTemplateEntry.getMetadata().getMetadataPropertyValue(SdcPropertyNames.PROPERTY_NAME_TYPE).equals(sdcType)){
- res.add(nodeTemplateEntry);
- }
- }*/
- return null;
+ @Override
+ //Sunny flow - covered with UT
+ public List<Input> getServiceInputs() {
+ return toscaTemplate.getInputs();
}
- private List<NodeTemplate> getNodeTemplateBySdcType(TopologyTemplate topologyTemplate, String sdcType){
- //Need metadata to fetch by type
+ @Override
+ //Sunny flow - covered with UT
+ public String getGroupPropertyLeafValue(Group group, String leafValuePath) {
+ if (group == null) {
+ log.error("getGroupPropertyLeafValue - group is null");
+ return null;
+ }
- List<NodeTemplate> nodeTemplates = topologyTemplate.getNodeTemplates();
- List<NodeTemplate> res = new ArrayList<>();
- for (NodeTemplate nodeTemplateEntry : nodeTemplates){
- //TODO switch back to type condition
- if (nodeTemplateEntry.getTypeDefinition().getType().contains("."+sdcType.toLowerCase()+".")){
- //if (sdcType.equals(nodeTemplateEntry.getMetadata().get(SdcPropertyNames.PROPERTY_NAME_TYPE))){
- res.add(nodeTemplateEntry);
- }
+ if (GeneralUtility.isEmptyString(leafValuePath)) {
+ log.error("getGroupPropertyLeafValue - leafValuePath is null or empty");
+ return null;
}
- return res;
+
+ String[] split = leafValuePath.split("#");
+ List<Property> properties = group.getProperties();
+ return processProperties(split, properties);
}
@Override
+ //Sunny flow - covered with UT
public List<NodeTemplate> getCpListByVf(String vfCustomizationId) {
+ List<NodeTemplate> cpList = new ArrayList<>();
+ if (GeneralUtility.isEmptyString(vfCustomizationId)){
+ log.error("getCpListByVf vfCustomizationId string is empty");
+ return cpList;
+ }
+
List<NodeTemplate> serviceVfList = getServiceVfList();
+ if (serviceVfList == null || serviceVfList.size() == 0){
+ log.error("getCpListByVf Vfs not exist for vfCustomizationId {}",vfCustomizationId);
+ return cpList;
+ }
NodeTemplate vfInstance = getNodeTemplateByCustomizationUuid(serviceVfList, vfCustomizationId);
- return getNodeTemplateBySdcType(vfInstance, Types.TYPE_CP);
+ log.debug("getCpListByVf vf list is {}", vfInstance);
+ if (vfInstance == null) {
+ log.debug("getCpListByVf vf list is null");
+ return cpList;
+ }
+ cpList = getNodeTemplateBySdcType(vfInstance, Types.TYPE_CP);
+ if(cpList == null || cpList.size()==0)
+ log.trace("getCpListByVf cps not exist for vfCustomizationId {}",vfCustomizationId);
+ return cpList;
}
@Override
- public List<String> getMembersOfGroup(Group group) {
- //Can be done
- return null;//toscaTemplate.getTopologyTemplate().getSubstitutionMappings().getNodeTemplates().get(0).get
+ //Sunny flow - covered with UT
+ public List<NodeTemplate> getMembersOfVfModule(NodeTemplate vf, Group vfModule) {
+ if (vf == null) {
+ log.error("getMembersOfVfModule - vf is null");
+ return new ArrayList<>();
+ }
+
+ if (vfModule == null) {
+ log.error("getMembersOfVfModule - vfModule is null");
+ return new ArrayList<>();
+ }
+
+ List<String> members = vfModule.getMembers();
+ if (members != null){
+ SubstitutionMappings substitutionMappings = vf.getSubstitutionMappings();
+ if (substitutionMappings != null){
+ return substitutionMappings.getNodeTemplates().stream().filter(x -> members.contains(x.getName())).collect(Collectors.toList());
+ }
+ }
+ return new ArrayList<>();
}
@Override
+ //Sunny flow - covered with UT
public List<Pair<NodeTemplate, NodeTemplate>> getNodeTemplatePairsByReqName(
List<NodeTemplate> listOfReqNodeTemplates, List<NodeTemplate> listOfCapNodeTemplates, String reqName) {
- //TODO - Can be done
- return new ArrayList<>();
+ if (listOfReqNodeTemplates == null || listOfCapNodeTemplates == null || reqName == null){
+ //TODO error message
+ return new ArrayList<>();
+ }
+
+ List<Pair<NodeTemplate, NodeTemplate>> pairsList = new ArrayList<>();
+
+ if (listOfReqNodeTemplates != null){
+ for (NodeTemplate reqNodeTemplate : listOfReqNodeTemplates) {
+ List<Map<String, Map<String, Object>>> requirements = reqNodeTemplate.getRequirements();
+ if (requirements != null){
+ for (Map<String, Map<String, Object>> reqEntry : requirements){
+ Map<String, Object> reqEntryMap = reqEntry.get(reqName);
+
+ if (reqEntryMap != null){
+ Object node = reqEntryMap.get("node");
+ if (node != null){
+ String nodeString = (String)node;
+ Optional<NodeTemplate> findFirst = listOfCapNodeTemplates.stream().filter(x -> x.getName().equals(nodeString)).findFirst();
+ if (findFirst.isPresent()){
+ pairsList.add(new ImmutablePair<NodeTemplate, NodeTemplate>(reqNodeTemplate, findFirst.get()));
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ return pairsList;
}
@Override
+ //Sunny flow - covered with UT
//TODO constant strings
public List<NodeTemplate> getAllottedResources() {
- List<NodeTemplate> nodeTemplates = toscaTemplate.getTopologyTemplate().getNodeTemplates();
- return nodeTemplates.stream().filter(x -> x.getMetadata() != null && x.getMetadata().get("category").equals("allotted_resources")).collect(Collectors.toList());
+ List<NodeTemplate> nodeTemplates = null;
+ nodeTemplates = toscaTemplate.getTopologyTemplate().getNodeTemplates();
+ if(nodeTemplates==null || nodeTemplates.size()==0 ){
+ log.error("getAllottedResources nodeTemplates not exist");
+ }
+ nodeTemplates = nodeTemplates.stream().filter(x -> x.getMetadata() != null && x.getMetadata().getValue("category").equals("Allotted Resources")).collect(Collectors.toList());
+ if(nodeTemplates==null || nodeTemplates.size()==0 ){
+ log.trace("getAllottedResources - allotted resources not exist");
+ }else
+ log.trace("getAllottedResources - the allotted resources list is {}", nodeTemplates);
+ return nodeTemplates;
}
-
@Override
//Sunny flow - covered with UT
public String getTypeOfNodeTemplate(NodeTemplate nodeTemplate) {
- //Can be done
+ if(nodeTemplate == null){
+
+ log.error("getTypeOfNodeTemplate nodeTemplate is null");
+ return null;
+ }
+ log.debug("getTypeOfNodeTemplate node template type is {}",nodeTemplate.getTypeDefinition().getType());
return nodeTemplate.getTypeDefinition().getType();
}
- /*//Not part of API, for inner/test use
- public NodeTemplate getNodeTemplateByName(TopologyTemplate topologyTemplate, String topologyName){
+ /************************************* helper functions ***********************************/
+ private List<NodeTemplate> getNodeTemplateBySdcType(NodeTemplate nodeTemplate, String sdcType){
+ if (nodeTemplate == null) {
+ log.error("getNodeTemplateBySdcType - nodeTemplate is null or empty");
+ return new ArrayList<>();
+ }
+
+ if (GeneralUtility.isEmptyString(sdcType)) {
+ log.error("getNodeTemplateBySdcType - sdcType is null or empty");
+ return new ArrayList<>();
+ }
+
+ SubstitutionMappings substitutionMappings = nodeTemplate.getSubstitutionMappings();
+
+ if (substitutionMappings != null) {
+ List<NodeTemplate> nodeTemplates = substitutionMappings.getNodeTemplates();
+ if (nodeTemplates != null && nodeTemplates.size() > 0)
+ return nodeTemplates.stream().filter(x -> (x.getMetadata() != null && sdcType.equals(x.getMetadata().getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)))).collect(Collectors.toList());
+ else
+ log.trace("getNodeTemplateBySdcType - SubstitutionMappings' node Templates not exist");
+ } else
+ log.trace("getNodeTemplateBySdcType - SubstitutionMappings not exist");
+
+ return new ArrayList<>();
+ }
+
+ private List<NodeTemplate> getNodeTemplateBySdcType(TopologyTemplate topologyTemplate, String sdcType){
+ if (GeneralUtility.isEmptyString(sdcType)) {
+ log.error("getNodeTemplateBySdcType - sdcType is null or empty");
+ return new ArrayList<>();
+ }
+
+ if (topologyTemplate == null) {
+ log.error("getNodeTemplateBySdcType - topologyTemplate is null");
+ return new ArrayList<>();
+ }
+
List<NodeTemplate> nodeTemplates = topologyTemplate.getNodeTemplates();
- Optional<NodeTemplate> findFirst = nodeTemplates.stream().filter(x -> x.getName().equals(topologyName)).findFirst();
- return findFirst.isPresent() ? findFirst.get() : null;
- }*/
+
+ if (nodeTemplates != null && nodeTemplates.size() > 0)
+ return nodeTemplates.stream().filter(x -> (x.getMetadata() != null && sdcType.equals(x.getMetadata().getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)))).collect(Collectors.toList());
+
+ log.trace("getNodeTemplateBySdcType - topologyTemplate's nodeTemplates not exist");
+ return new ArrayList<>();
+ }
+
+ //Assumed to be unique property for the list
+ private NodeTemplate getNodeTemplateByCustomizationUuid(List<NodeTemplate> nodeTemplates, String customizationId){
+ for (NodeTemplate nodeTemplate : nodeTemplates){
+ if (customizationId.equals(nodeTemplate.getMetadata().getValue(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID))){
+ return nodeTemplate;
+ }
+ }
+ return null;
+ }
+
+ private String processProperties(String[] split, List<Property> properties) {
+ log.trace("processProperties - the leafValuePath is {} , the properties are {}", split.toString(), properties.toString());
+ Optional<Property> findFirst = properties.stream().filter(x -> x.getName().equals(split[0])).findFirst();
+ if (findFirst.isPresent()){
+ log.trace("processProperties - find first item is {}", findFirst.get().toString());
+ Property property = findFirst.get();
+ Object current = property.getValue();
+ if (current == null){
+ log.error("processProperties - this property has no value");
+ return null;
+ }
+ if (split.length > 1){
+ current = new Yaml().load((String)current);
+ for (int i = 1; i < split.length; i++) {
+ if (current instanceof Map){
+ current = ((Map<String, Object>)current).get(split[i]);
+ } else {
+ log.error("processProperties - found an unexpected leaf where expected to find a complex type");
+ return null;
+ }
+ }
+ }
+ if (current != null){
+ log.trace("processProperties - the property value is {}", String.valueOf(current));
+ return String.valueOf(current);
+ }
+ }
+ log.error("processProperties - Dont find property");
+ return null;
+ }
}
package org.openecomp.sdc.tosca.parser.impl;\r
\r
import java.io.IOException;\r
+import java.util.List;\r
\r
import org.openecomp.sdc.tosca.parser.api.ISdcCsarHelper;\r
import org.openecomp.sdc.tosca.parser.exceptions.SdcToscaParserException;\r
+import org.openecomp.sdc.toscaparser.ToscaParser;\r
import org.openecomp.sdc.toscaparser.ToscaParserFactory;\r
+import org.openecomp.sdc.toscaparser.api.NodeTemplate;\r
+import org.openecomp.sdc.toscaparser.api.ToscaTemplate;\r
\r
public class SdcToscaParserFactory implements AutoCloseable{\r
\r
throw new SdcToscaParserException("The factory is closed. It was probably closed too soon.");\r
}\r
try {\r
- return new SdcCsarHelperImpl(toscaParserFactory.create().parse(csarPath));\r
+ ToscaParser create = toscaParserFactory.create();\r
+ ToscaTemplate parse = create.parse(csarPath);\r
+ SdcCsarHelperImpl sdcCsarHelperImpl = new SdcCsarHelperImpl(parse);\r
+ return sdcCsarHelperImpl;\r
} catch (IOException e) {\r
throw new SdcToscaParserException("Exception when creating the parser: "+e.getMessage());\r
}\r
}\r
}\r
}\r
+ \r
+ public static void main(String[] args) throws SdcToscaParserException {\r
+ try (SdcToscaParserFactory factory = SdcToscaParserFactory.getInstance()){ //Autoclosable\r
+ ISdcCsarHelper sdcCsarHelper = factory.getSdcCsarHelper("C:\\Users\\pa0916\\Desktop\\Work\\ASDC\\CSARs\\csar_hello_world.zip");\r
+ //Can run methods on the helper\r
+ List<NodeTemplate> allottedResources = sdcCsarHelper.getAllottedResources();\r
+ //..............\r
+ }\r
+ }\r
}
\ No newline at end of file
--- /dev/null
+package org.openecomp.sdc.tosca.parser.utils;
+
+public class GeneralUtility {
+
+ public static boolean isEmptyString(String str){
+ return str == null || str.trim().isEmpty();
+ }
+}
package org.openecomp.sdc.impl;\r
\r
+import static org.junit.Assert.assertEquals;\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.assertNull;\r
+import static org.junit.Assert.assertTrue;\r
+\r
import java.io.File;\r
+import java.util.ArrayList;\r
import java.util.List;\r
-import java.util.Map;\r
\r
+import org.apache.commons.lang3.tuple.Pair;\r
import org.junit.AfterClass;\r
-import static org.junit.Assert.*;\r
import org.junit.BeforeClass;\r
import org.junit.Test;\r
import org.openecomp.sdc.tosca.parser.api.ISdcCsarHelper;\r
import org.openecomp.sdc.tosca.parser.exceptions.SdcToscaParserException;\r
import org.openecomp.sdc.tosca.parser.impl.SdcToscaParserFactory;\r
+import org.openecomp.sdc.toscaparser.api.Group;\r
+import org.openecomp.sdc.toscaparser.api.Metadata;\r
import org.openecomp.sdc.toscaparser.api.NodeTemplate;\r
+import org.openecomp.sdc.toscaparser.api.parameters.Input;\r
\r
public class ToscaParserStubsTest {\r
\r
- private static ISdcCsarHelper csarHelper;\r
- private static SdcToscaParserFactory factory;\r
-\r
+ static SdcToscaParserFactory factory;\r
+ static ISdcCsarHelper rainyCsarHelperSingleVf;\r
+ static ISdcCsarHelper rainyCsarHelperMultiVfs;\r
+ static ISdcCsarHelper rainyCsarHelperNoVf;\r
+ static ISdcCsarHelper sunnyCsarHelperMultipleVf;\r
\r
@BeforeClass\r
public static void init() throws SdcToscaParserException{\r
+ long startTime = System.currentTimeMillis();\r
factory = SdcToscaParserFactory.getInstance();\r
- //csarHelper = factory.getSdcCsarHelper("C:\\Users\\pa0916\\Desktop\\Work\\ASDC\\CSARs\\service-ServiceFdnt-csar-allotted-resources-4.csar");\r
- String fileStr = ToscaParserStubsTest.class.getClassLoader().getResource("csars/service-ServiceFdnt-csar-allotted-resources-4.csar").getFile();\r
+ long estimatedTime = System.currentTimeMillis() - startTime; \r
+ System.out.println("Time to init factory "+estimatedTime);\r
+ String fileStr2 = ToscaParserStubsTest.class.getClassLoader().getResource("csars/service-ServiceFdnt-csar-group-meta-10.csar").getFile();\r
+ File file2 = new File(fileStr2);\r
+ startTime = System.currentTimeMillis();\r
+ sunnyCsarHelperMultipleVf = factory.getSdcCsarHelper(file2.getAbsolutePath());\r
+ estimatedTime = System.currentTimeMillis() - startTime; \r
+ System.out.println("init CSAR Execution time: "+estimatedTime);\r
+ String fileStr = ToscaParserStubsTest.class.getClassLoader().getResource("csars/service-ServiceFdnt-csar-rainy.csar").getFile();\r
File file = new File(fileStr);\r
- csarHelper = factory.getSdcCsarHelper(file.getAbsolutePath());\r
+ rainyCsarHelperMultiVfs = factory.getSdcCsarHelper(file.getAbsolutePath());\r
+ String fileStr3 = ToscaParserStubsTest.class.getClassLoader().getResource("csars/service-ServiceFdnt-csar.csar").getFile();\r
+ File file3 = new File(fileStr3);\r
+ rainyCsarHelperSingleVf = factory.getSdcCsarHelper(file3.getAbsolutePath());\r
+ String fileStr4 = ToscaParserStubsTest.class.getClassLoader().getResource("csars/service-ServiceFdnt-csar-no-vf.csar").getFile();\r
+ File file4 = new File(fileStr3);\r
+ rainyCsarHelperNoVf = factory.getSdcCsarHelper(file3.getAbsolutePath());\r
}\r
-\r
-\r
+ \r
@Test\r
- //TODO add rainy flows\r
public void testNumberOfVfSunnyFlow() throws SdcToscaParserException {\r
- List<NodeTemplate> serviceVfList = csarHelper.getServiceVfList();\r
+ List<NodeTemplate> serviceVfList = sunnyCsarHelperMultipleVf.getServiceVfList();\r
assertNotNull(serviceVfList);\r
- assertEquals(1, serviceVfList.size());\r
+ assertEquals(2, serviceVfList.size());\r
}\r
\r
@Test\r
- //TODO add rainy flows\r
public void testNodeTemplateFlatProperty() throws SdcToscaParserException {\r
- List<NodeTemplate> serviceVfList = csarHelper.getServiceVfList();\r
- String nodeTemplatePropertyLeafValue = csarHelper.getNodeTemplatePropertyLeafValue(serviceVfList.get(0), "availability_zone_max_count");\r
+ List<NodeTemplate> serviceVfList = sunnyCsarHelperMultipleVf.getServiceVfList();\r
+ String nodeTemplatePropertyLeafValue = sunnyCsarHelperMultipleVf.getNodeTemplatePropertyLeafValue(serviceVfList.get(0), "availability_zone_max_count");\r
assertEquals("2", nodeTemplatePropertyLeafValue);\r
}\r
+ \r
+ @Test\r
+ public void testGroupFlatProperty() throws SdcToscaParserException {\r
+ List<Group> vfModulesByVf = sunnyCsarHelperMultipleVf.getVfModulesByVf("56179cd8-de4a-4c38-919b-bbc4452d2d72");\r
+ String volumeGroup = sunnyCsarHelperMultipleVf.getGroupPropertyLeafValue(vfModulesByVf.get(0), "volume_group");\r
+ assertEquals("false", volumeGroup);\r
+ }\r
\r
@Test\r
- //TODO add rainy flows\r
public void testNodeTemplateNestedProperty() throws SdcToscaParserException {\r
- List<NodeTemplate> serviceVfList = csarHelper.getServiceVfList();\r
- String nodeTemplatePropertyLeafValue = csarHelper.getNodeTemplatePropertyLeafValue(serviceVfList.get(0), "nf_role#nf_naming#instance_name");\r
- assertEquals("FDNT_instance_VF", nodeTemplatePropertyLeafValue);\r
+ List<NodeTemplate> serviceVfList = sunnyCsarHelperMultipleVf.getServiceVfList();\r
+ String nodeTemplatePropertyLeafValue = sunnyCsarHelperMultipleVf.getNodeTemplatePropertyLeafValue(serviceVfList.get(0), "nf_role#nf_naming#ecomp_generated_naming");\r
+ assertEquals("false", nodeTemplatePropertyLeafValue);\r
}\r
\r
@Test\r
- //TODO add rainy flows\r
public void testServiceNodeTemplatesByType() throws SdcToscaParserException {\r
- List<NodeTemplate> serviceVfList = csarHelper.getServiceNodeTemplatesByType("org.openecomp.resource.vf.Fdnt");\r
+ List<NodeTemplate> serviceVfList = sunnyCsarHelperMultipleVf.getServiceNodeTemplatesByType("org.openecomp.resource.vf.Fdnt");\r
assertNotNull(serviceVfList);\r
- assertEquals(1, serviceVfList.size());\r
+ assertEquals(2, serviceVfList.size());\r
}\r
\r
@Test\r
- //TODO add rainy flows\r
public void testGetTypeOfNodeTemplate() {\r
- List<NodeTemplate> serviceVfList = csarHelper.getServiceVfList();\r
- String typeOfNodeTemplate = csarHelper.getTypeOfNodeTemplate(serviceVfList.get(0));\r
+ List<NodeTemplate> serviceVfList = sunnyCsarHelperMultipleVf.getServiceVfList();\r
+ String typeOfNodeTemplate = sunnyCsarHelperMultipleVf.getTypeOfNodeTemplate(serviceVfList.get(0));\r
assertEquals("org.openecomp.resource.vf.Fdnt", typeOfNodeTemplate);\r
}\r
\r
-\r
- //@Test\r
- //TODO add rainy flows\r
+ @Test\r
public void testGetServiceMetadata() {\r
- //FAILS!! Metadata is null\r
- Map<String, String> serviceMetadata = csarHelper.getServiceMetadata();\r
+ Metadata serviceMetadata = sunnyCsarHelperMultipleVf.getServiceMetadata();\r
assertNotNull(serviceMetadata);\r
- assertEquals("78c72999-1003-4a35-8534-bbd7d96fcae3", serviceMetadata.get("invariantUUID"));\r
- assertEquals("Service FDNT", serviceMetadata.get("name"));\r
- assertEquals("true", serviceMetadata.get("serviceEcompNaming"));\r
+ assertEquals("78c72999-1003-4a35-8534-bbd7d96fcae3", serviceMetadata.getValue("invariantUUID"));\r
+ assertEquals("Service FDNT", serviceMetadata.getValue("name"));\r
+ assertEquals("true", String.valueOf(serviceMetadata.getValue("serviceEcompNaming")));\r
}\r
\r
@Test\r
- //TODO add rainy flows\r
public void testGetAllottedResources() {\r
- List<NodeTemplate> allottedResources = csarHelper.getAllottedResources();\r
- assertEquals(1, allottedResources.size());\r
+ List<NodeTemplate> allottedResources = sunnyCsarHelperMultipleVf.getAllottedResources();\r
+ assertEquals(2, allottedResources.size());\r
+ }\r
+\r
+ @Test\r
+ public void testGetServiceSubstitutionMappingsTypeName() {\r
+ String serviceSubstitutionMappingsTypeName = sunnyCsarHelperMultipleVf.getServiceSubstitutionMappingsTypeName();\r
+ assertEquals("org.openecomp.service.ServiceFdnt", serviceSubstitutionMappingsTypeName);\r
+ }\r
+ \r
+ @Test\r
+ public void testGetVfcFromVf(){\r
+ List<NodeTemplate> vfcListByVf = sunnyCsarHelperMultipleVf.getVfcListByVf("56179cd8-de4a-4c38-919b-bbc4452d2d72");\r
+ assertEquals(2, vfcListByVf.size());\r
+ }\r
+ \r
+ @Test\r
+ public void testGetCpFromVf(){\r
+ List<NodeTemplate> cpListByVf = sunnyCsarHelperMultipleVf.getCpListByVf("56179cd8-de4a-4c38-919b-bbc4452d2d72");\r
+ assertEquals(1, cpListByVf.size());\r
+ NodeTemplate nodeTemplate = cpListByVf.get(0);\r
+ assertEquals("DNT_PORT", nodeTemplate.getName());\r
+ }\r
+ \r
+ @Test\r
+ public void testServiceVl(){\r
+ List<NodeTemplate> vlList = sunnyCsarHelperMultipleVf.getServiceVlList();\r
+ assertEquals(1, vlList.size());\r
+ }\r
+ \r
+ @Test\r
+ public void testVfModulesFromVf(){\r
+ List<Group> vfModulesByVf = sunnyCsarHelperMultipleVf.getVfModulesByVf("56179cd8-de4a-4c38-919b-bbc4452d2d72");\r
+ assertEquals(2, vfModulesByVf.size());\r
+ }\r
+ \r
+ @Test\r
+ public void testGetNodeTemplatePairsByReqName(){\r
+ List<Pair<NodeTemplate, NodeTemplate>> nodeTemplatePairsByReqName = sunnyCsarHelperMultipleVf.getNodeTemplatePairsByReqName(sunnyCsarHelperMultipleVf.getCpListByVf("56179cd8-de4a-4c38-919b-bbc4452d2d72"), sunnyCsarHelperMultipleVf.getVfcListByVf("56179cd8-de4a-4c38-919b-bbc4452d2d72"), "binding");\r
+ assertNotNull(nodeTemplatePairsByReqName);\r
+ assertEquals(1, nodeTemplatePairsByReqName.size());\r
+ Pair<NodeTemplate, NodeTemplate> pair = nodeTemplatePairsByReqName.get(0);\r
+ NodeTemplate cp = pair.getLeft();\r
+ NodeTemplate vfc = pair.getRight();\r
+ assertEquals("DNT_PORT", cp.getName());\r
+ assertEquals("DNT_FW_RHRG", vfc.getName());\r
+ }\r
+ \r
+ @Test\r
+ public void testGetMembersOfVfModule(){\r
+ NodeTemplate vf = sunnyCsarHelperMultipleVf.getServiceVfList().get(0);\r
+ List<Group> vfModulesByVf = sunnyCsarHelperMultipleVf.getVfModulesByVf(vf.getMetadata().getValue("customizationUUID"));\r
+ assertEquals(2, vfModulesByVf.size());\r
+ for (Group group : vfModulesByVf){\r
+ List<NodeTemplate> membersOfVfModule = sunnyCsarHelperMultipleVf.getMembersOfVfModule(vf, group);\r
+ assertNotNull(membersOfVfModule);\r
+ if (group.getName().equals("Fdnt..base_stsi_dnt_frwl..module-0")){\r
+ assertEquals(1, membersOfVfModule.size());\r
+ NodeTemplate nodeTemplate = membersOfVfModule.get(0);\r
+ assertEquals("DNT_FW_RSG_SI_1", nodeTemplate.getName());\r
+ } else {\r
+ assertEquals("Fdnt..mod_vmsi_dnt_fw_parent..module-1", group.getName());\r
+ assertEquals(1, membersOfVfModule.size());\r
+ NodeTemplate nodeTemplate = membersOfVfModule.get(0);\r
+ assertEquals("DNT_FW_RHRG", nodeTemplate.getName());\r
+ }\r
+ }\r
+ }\r
+ \r
+ @Test\r
+ public void testGetServiceInputs(){\r
+ List<Input> serviceInputs = sunnyCsarHelperMultipleVf.getServiceInputs();\r
+ assertNotNull(serviceInputs);\r
+ assertEquals(1, serviceInputs.size());\r
+ }\r
+\r
+ @Test\r
+ public void testGetMetadataProperty(){\r
+ Metadata serviceMetadata = sunnyCsarHelperMultipleVf.getServiceMetadata();\r
+ String metadataPropertyValue = sunnyCsarHelperMultipleVf.getMetadataPropertyValue(serviceMetadata, "invariantUUID");\r
+ assertEquals("78c72999-1003-4a35-8534-bbd7d96fcae3", metadataPropertyValue);\r
+ }\r
+\r
+ @Test\r
+ public void testGetGroupMetadata(){\r
+ NodeTemplate vf = sunnyCsarHelperMultipleVf.getServiceVfList().get(0);\r
+ List<Group> vfModulesByVf = sunnyCsarHelperMultipleVf.getVfModulesByVf(vf.getMetadata().getValue("customizationUUID"));\r
+ boolean found = false;\r
+ for (Group group : vfModulesByVf){\r
+ if (group.getName().equals("Fdnt..base_stsi_dnt_frwl..module-0")){\r
+ found = true;\r
+ Metadata metadata = group.getMetadata();\r
+ assertNotNull(metadata);\r
+ assertEquals("1", metadata.getValue("vfModuleModelVersion"));\r
+ } \r
+ }\r
+ assertTrue(found);\r
+ }\r
+ \r
+ \r
+ @Test\r
+ public void testGetServiceInputLeafValue(){\r
+ String serviceInputLeafValue = sunnyCsarHelperMultipleVf.getServiceInputLeafValueOfDefault("service_naming#default");\r
+ assertEquals("test service naming", serviceInputLeafValue);\r
+ }\r
+\r
+ \r
+ /***************** RAINY TESTS ***************************/\r
+ \r
+ \r
+ @Test\r
+ public void testGetServiceInputLeafValueNotExists(){\r
+ String serviceInputLeafValue = sunnyCsarHelperMultipleVf.getServiceInputLeafValueOfDefault("service_naming#default#kuku");\r
+ assertNull(serviceInputLeafValue);\r
+ }\r
+\r
+ @Test\r
+ public void testGetServiceInputLeafValueNull(){\r
+ String serviceInputLeafValue = sunnyCsarHelperMultipleVf.getServiceInputLeafValueOfDefault(null);\r
+ assertNull(serviceInputLeafValue);\r
}\r
\r
+ @Test\r
+ public void testNodeTemplateNestedPropertyNotExists() throws SdcToscaParserException {\r
+ List<NodeTemplate> serviceVfList = sunnyCsarHelperMultipleVf.getServiceVfList();\r
+ String nodeTemplatePropertyLeafValue = sunnyCsarHelperMultipleVf.getNodeTemplatePropertyLeafValue(serviceVfList.get(0), "nf_role#nf_naming#kuku");\r
+ assertNull(nodeTemplatePropertyLeafValue);\r
+ }\r
\r
- @AfterClass\r
- public static void close(){\r
- factory.close();\r
+ @Test\r
+ public void testGetGroupEmptyMetadata(){\r
+ NodeTemplate vf = sunnyCsarHelperMultipleVf.getServiceVfList().get(0);\r
+ List<Group> vfModulesByVf = sunnyCsarHelperMultipleVf.getVfModulesByVf(vf.getMetadata().getValue("customizationUUID"));\r
+ boolean found = false;\r
+ for (Group group : vfModulesByVf){\r
+ if (group.getName().equals("Fdnt..mod_vmsi_dnt_fw_parent..module-1")){\r
+ found = true;\r
+ Metadata metadata = group.getMetadata();\r
+ assertNull(metadata);\r
+ } \r
}\r
+ assertTrue(found);\r
+ }\r
+ \r
+ @Test\r
+ public void testNodeTemplateFlatPropertyByNotFoundProperty() throws SdcToscaParserException {\r
+ List<NodeTemplate> serviceVfList = rainyCsarHelperMultiVfs.getServiceVfList();\r
+ String nodeTemplatePropertyLeafValue = rainyCsarHelperMultiVfs.getNodeTemplatePropertyLeafValue(serviceVfList.get(0), "XXXX");\r
+ assertNull(nodeTemplatePropertyLeafValue);\r
+ }\r
+\r
+ @Test\r
+ public void testNodeTemplateFlatPropertyByNullProperty() throws SdcToscaParserException {\r
+ List<NodeTemplate> serviceVfList = rainyCsarHelperMultiVfs.getServiceVfList();\r
+ String nodeTemplatePropertyLeafValue = rainyCsarHelperMultiVfs.getNodeTemplatePropertyLeafValue(serviceVfList.get(0), null);\r
+ assertNull(nodeTemplatePropertyLeafValue);\r
+ }\r
+\r
+ @Test\r
+ public void testNodeTemplateFlatPropertyByNullNodeTemplate() throws SdcToscaParserException {\r
+ String nodeTemplatePropertyLeafValue = rainyCsarHelperMultiVfs.getNodeTemplatePropertyLeafValue(null, "availability_zone_max_count");\r
+ assertNull(nodeTemplatePropertyLeafValue);\r
+ }\r
+\r
+ @Test\r
+ public void testNumberOfVLRainyFlow() throws SdcToscaParserException {\r
+ List<NodeTemplate> serviceVlList = rainyCsarHelperMultiVfs.getServiceVlList();\r
+ assertNotNull(serviceVlList);\r
+ assertEquals(0, serviceVlList.size());\r
+ }\r
+\r
+ @Test\r
+ public void testSingleVFWithNotMetadata() throws SdcToscaParserException {\r
+ //If there is no metadata on VF level - There is no VF's because the type is taken from metadata values.\r
+ List<NodeTemplate> serviceVfList = rainyCsarHelperSingleVf.getServiceVfList();\r
+ assertNotNull(serviceVfList);\r
+ assertEquals(0, serviceVfList.size());\r
+ }\r
+\r
+ @Test\r
+ public void testGetNullMetadataPropertyValue() {\r
+ String value = rainyCsarHelperMultiVfs.getMetadataPropertyValue(null, "XXX");\r
+ assertNull(value);\r
+ }\r
+\r
+ @Test\r
+ public void testGetMetadataByNullPropertyValue() {\r
+ Metadata metadata = rainyCsarHelperMultiVfs.getServiceMetadata();\r
+ String value = rainyCsarHelperMultiVfs.getMetadataPropertyValue(metadata, null);\r
+ assertNull(value);\r
+ }\r
+\r
+ @Test\r
+ public void testGetMetadataByEmptyPropertyValue() {\r
+ Metadata metadata = rainyCsarHelperMultiVfs.getServiceMetadata();\r
+ String value = rainyCsarHelperMultiVfs.getMetadataPropertyValue(metadata, "");\r
+ assertNull(value);\r
+ }\r
+\r
+ @Test\r
+ public void testGetCpFromVfByNullId() {\r
+ List<NodeTemplate> cpListByVf = rainyCsarHelperMultiVfs.getCpListByVf(null);\r
+ assertNotNull(cpListByVf);\r
+ assertEquals(0, cpListByVf.size());\r
+ }\r
+\r
+ @Test\r
+ public void testGetAllottedResourcesZero() {\r
+ List<NodeTemplate> allottedResources = rainyCsarHelperMultiVfs.getAllottedResources();\r
+ assertNotNull(allottedResources);\r
+ assertEquals(0, allottedResources.size());\r
+ }\r
+\r
+ @Test\r
+ public void testGetTypeOfNullNodeTemplate() {\r
+ String typeOfNodeTemplate = rainyCsarHelperMultiVfs.getTypeOfNodeTemplate(null);\r
+ assertNull(typeOfNodeTemplate);\r
+ }\r
+\r
+ @Test\r
+ public void testGetCpFromVfXxx() {\r
+ List<NodeTemplate> cpListByVf = rainyCsarHelperMultiVfs.getCpListByVf("XXXXX");\r
+ assertNotNull(cpListByVf);\r
+ assertEquals(0, cpListByVf.size());\r
+ }\r
+\r
+ @Test\r
+ public void testServiceNodeTemplatesByNull() {\r
+ List<NodeTemplate> nodeTemplates = rainyCsarHelperMultiVfs.getServiceNodeTemplatesByType(null);\r
+ assertNotNull(nodeTemplates);\r
+ assertEquals(0, nodeTemplates.size());\r
+ }\r
+\r
+ @Test\r
+ public void testServiceNodeTemplatesByNotFoundProperty() {\r
+ List<NodeTemplate> nodeTemplates = rainyCsarHelperMultiVfs.getServiceNodeTemplatesByType("XXX");\r
+ assertNotNull(nodeTemplates);\r
+ assertEquals(0, nodeTemplates.size());\r
+ }\r
+\r
+ @Test\r
+ public void testVfcListByNull() {\r
+ List<NodeTemplate> vfcList = rainyCsarHelperMultiVfs.getVfcListByVf(null);\r
+ assertNotNull(vfcList);\r
+ assertEquals(0, vfcList.size());\r
+ }\r
+\r
+ @Test\r
+ public void testVfcListByNotFoundProperty() {\r
+ List<NodeTemplate> vfcList = rainyCsarHelperMultiVfs.getVfcListByVf("XXX");\r
+ assertNotNull(vfcList);\r
+ assertEquals(0, vfcList.size());\r
+ }\r
+\r
+ @Test\r
+ public void testServiceSubstitutionMappingsTypeName() {\r
+ String substitutionMappingsTypeName = rainyCsarHelperMultiVfs.getServiceSubstitutionMappingsTypeName();\r
+ assertNull(substitutionMappingsTypeName);\r
+ }\r
+\r
+ @Test\r
+ public void testServiceMetadata() {\r
+ Metadata metadata = rainyCsarHelperSingleVf.getServiceMetadata();\r
+ assertNull(metadata);\r
+ }\r
+ \r
+ @Test\r
+ public void testGetVfModuleNonExisitingVf() {\r
+ List<Group> vfModulesByVf = rainyCsarHelperSingleVf.getVfModulesByVf("dummy");\r
+ assertNotNull(vfModulesByVf);\r
+ assertEquals(0, vfModulesByVf.size());\r
+ }\r
+\r
+ @Test\r
+ public void testGetVfModuleNullVf() {\r
+ List<Group> vfModulesByVf = rainyCsarHelperSingleVf.getVfModulesByVf(null);\r
+ assertNotNull(vfModulesByVf);\r
+ assertEquals(0, vfModulesByVf.size());\r
+ }\r
+\r
+ @Test\r
+ public void testGroupPropertyLeafValueByNullGroup() {\r
+ String groupProperty = sunnyCsarHelperMultipleVf.getGroupPropertyLeafValue(null, "volume_group");\r
+ assertNull(groupProperty);\r
+ }\r
+\r
+ @Test\r
+ public void testGroupPropertyLeafValueByNullProperty() {\r
+ List<Group> vfModulesByVf = sunnyCsarHelperMultipleVf.getVfModulesByVf("56179cd8-de4a-4c38-919b-bbc4452d2d72");\r
+ String groupProperty = sunnyCsarHelperMultipleVf.getGroupPropertyLeafValue(vfModulesByVf.get(0), null);\r
+ assertNull(groupProperty);\r
+ }\r
+\r
+ @Test\r
+ public void testGroupPropertyLeafValueByDummyProperty() {\r
+ List<Group> vfModulesByVf = sunnyCsarHelperMultipleVf.getVfModulesByVf("56179cd8-de4a-4c38-919b-bbc4452d2d72");\r
+ String groupProperty = sunnyCsarHelperMultipleVf.getGroupPropertyLeafValue(vfModulesByVf.get(0), "XXX");\r
+ assertNull(groupProperty);\r
+ }\r
+\r
+ @Test\r
+ public void testMembersOfVfModuleByNullVf() {\r
+ List<Group> vfModulesByVf = sunnyCsarHelperMultipleVf.getVfModulesByVf("56179cd8-de4a-4c38-919b-bbc4452d2d72");\r
+ List<NodeTemplate> nodeTemplates = sunnyCsarHelperMultipleVf.getMembersOfVfModule(null, vfModulesByVf.get(0));\r
+ assertNotNull(nodeTemplates);\r
+ assertEquals(0, nodeTemplates.size());\r
+ }\r
+\r
+ @Test\r
+ public void testMembersOfVfModuleByNullGroup() {\r
+ List<NodeTemplate> serviceVfList = rainyCsarHelperMultiVfs.getServiceVfList();\r
+ List<NodeTemplate> nodeTemplates = rainyCsarHelperMultiVfs.getMembersOfVfModule(serviceVfList.get(0), null);\r
+ assertNotNull(nodeTemplates);\r
+ assertEquals(0, nodeTemplates.size());\r
+ }\r
+\r
+ @Test\r
+ public void testGetNodeTemplatePairsByReqNameWithNullVF(){\r
+ List<Pair<NodeTemplate, NodeTemplate>> nodeTemplatePairsByReqName = sunnyCsarHelperMultipleVf.getNodeTemplatePairsByReqName(\r
+ null, sunnyCsarHelperMultipleVf.getVfcListByVf("56179cd8-de4a-4c38-919b-bbc4452d2d72"), "binding");\r
+ assertNotNull(nodeTemplatePairsByReqName);\r
+ assertEquals(0, nodeTemplatePairsByReqName.size());\r
+ }\r
+\r
+ @Test\r
+ public void testGetNodeTemplatePairsByReqNameWithEmptyVF(){\r
+ List<Pair<NodeTemplate, NodeTemplate>> nodeTemplatePairsByReqName = sunnyCsarHelperMultipleVf.getNodeTemplatePairsByReqName(\r
+ new ArrayList<>(), sunnyCsarHelperMultipleVf.getVfcListByVf("56179cd8-de4a-4c38-919b-bbc4452d2d72"), "binding");\r
+ assertNotNull(nodeTemplatePairsByReqName);\r
+ assertEquals(0, nodeTemplatePairsByReqName.size());\r
+ }\r
+\r
+ @Test\r
+ public void testGetNodeTemplatePairsByReqNameWithNullCap(){\r
+ List<Pair<NodeTemplate, NodeTemplate>> nodeTemplatePairsByReqName = sunnyCsarHelperMultipleVf.getNodeTemplatePairsByReqName(\r
+ sunnyCsarHelperMultipleVf.getCpListByVf("56179cd8-de4a-4c38-919b-bbc4452d2d72"), null, "binding");\r
+ assertNotNull(nodeTemplatePairsByReqName);\r
+ assertEquals(0, nodeTemplatePairsByReqName.size());\r
+ }\r
+\r
+ @Test\r
+ public void testGetNodeTemplatePairsByReqNameWithEmptyCap(){\r
+ List<Pair<NodeTemplate, NodeTemplate>> nodeTemplatePairsByReqName = sunnyCsarHelperMultipleVf.getNodeTemplatePairsByReqName(\r
+ sunnyCsarHelperMultipleVf.getCpListByVf("56179cd8-de4a-4c38-919b-bbc4452d2d72"), new ArrayList<>(), "binding");\r
+ assertNotNull(nodeTemplatePairsByReqName);\r
+ assertEquals(0, nodeTemplatePairsByReqName.size());\r
+ }\r
+\r
+ @Test\r
+ public void testGetNodeTemplatePairsByReqNameWithNullReq(){\r
+ List<Pair<NodeTemplate, NodeTemplate>> nodeTemplatePairsByReqName = sunnyCsarHelperMultipleVf.getNodeTemplatePairsByReqName(\r
+ sunnyCsarHelperMultipleVf.getCpListByVf("56179cd8-de4a-4c38-919b-bbc4452d2d72"), sunnyCsarHelperMultipleVf.getVfcListByVf("56179cd8-de4a-4c38-919b-bbc4452d2d72"), null);\r
+ assertNotNull(nodeTemplatePairsByReqName);\r
+ assertEquals(0, nodeTemplatePairsByReqName.size());\r
+ }\r
+\r
+ @Test\r
+ public void testGetNodeTemplatePairsByReqNameWithDummyReq(){\r
+ List<Pair<NodeTemplate, NodeTemplate>> nodeTemplatePairsByReqName = sunnyCsarHelperMultipleVf.getNodeTemplatePairsByReqName(\r
+ sunnyCsarHelperMultipleVf.getCpListByVf("56179cd8-de4a-4c38-919b-bbc4452d2d72"), sunnyCsarHelperMultipleVf.getVfcListByVf("56179cd8-de4a-4c38-919b-bbc4452d2d72"), "XXX");\r
+ assertNotNull(nodeTemplatePairsByReqName);\r
+ assertEquals(0, nodeTemplatePairsByReqName.size());\r
+ }\r
+\r
+ @Test\r
+ public void testServiceInputs() {\r
+ List<Input> inputs = rainyCsarHelperSingleVf.getServiceInputs();\r
+ assertNotNull(inputs);\r
+ assertEquals(0, inputs.size());\r
+ }\r
+\r
+ @Test\r
+ public void testServiceWithoutVF() {\r
+ List<NodeTemplate> vfList = rainyCsarHelperNoVf.getServiceVfList();\r
+ assertNotNull(vfList);\r
+ assertEquals(0, vfList.size());\r
+ }\r
+\r
+ @AfterClass\r
+ public static void close(){\r
+ long startTime = System.currentTimeMillis();\r
+ factory.close();\r
+ long estimatedTime = System.currentTimeMillis() - startTime; \r
+ System.out.println("close Execution time: "+estimatedTime);\r
}\r
+}\r
Code Review / sdc / sdc-distribution-client.git / commitdiff