import static org.openecomp.sdc.be.components.utils.InterfaceOperationUtils.isOperationInputMappedToComponentInput;
import static org.openecomp.sdc.be.components.utils.PropertiesUtils.getPropertyCapabilityFromAllCapProps;
import static org.openecomp.sdc.be.components.utils.PropertiesUtils.isCapabilityProperty;
-import static org.openecomp.sdc.be.tosca.utils.InterfacesOperationsToscaUtil.SELF;
+import static org.openecomp.sdc.be.tosca.InterfacesOperationsConverter.SELF;
@Component("interfaceOperationBusinessLogic")
public class InterfaceOperationBusinessLogic extends BaseBusinessLogic {
import static org.openecomp.sdc.be.components.utils.InterfaceOperationUtils.getOperationOutputName;
import static org.openecomp.sdc.be.components.utils.InterfaceOperationUtils.isOperationInputMappedToOtherOperationOutput;
import static org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum.UPDATE_SERVICE_METADATA;
-import static org.openecomp.sdc.be.tosca.utils.InterfacesOperationsToscaUtil.SELF;
+import static org.openecomp.sdc.be.tosca.InterfacesOperationsConverter.SELF;
import static org.openecomp.sdc.be.types.ServiceConsumptionSource.SERVICE_INPUT;
import static org.openecomp.sdc.be.types.ServiceConsumptionSource.STATIC;
import org.openecomp.sdc.be.model.tosca.ToscaFunctions;
import org.openecomp.sdc.be.tosca.PropertyConvertor;
import org.openecomp.sdc.common.log.wrappers.Logger;
+import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
private final PropertyValueMerger propertyValueMerger;
private final ApplicationDataTypeCache dataTypeCache;
- private final PropertyConvertor propertyConvertor = PropertyConvertor.getInstance();
+ private final PropertyConvertor propertyConvertor;
private final Gson gson = new Gson();
-
- public PropertyDataValueMergeBusinessLogic(PropertyValueMerger propertyValueMerger, ApplicationDataTypeCache dataTypeCache) {
+ @Autowired
+ public PropertyDataValueMergeBusinessLogic(PropertyValueMerger propertyValueMerger,
+ ApplicationDataTypeCache dataTypeCache, PropertyConvertor propertyConvertor) {
this.propertyValueMerger = propertyValueMerger;
this.dataTypeCache = dataTypeCache;
+ this.propertyConvertor = propertyConvertor;
}
/**
String propValue = propertyDataDefinition.getValue() == null ? "": propertyDataDefinition.getValue();
String propertyType = propertyDataDefinition.getType();
String innerType = propertyDataDefinition.getSchemaType();
- return propertyConvertor.convertToToscaObject(propertyType, propValue, innerType, dataTypes, true);
+ return propertyConvertor.convertToToscaObject(propertyDataDefinition, propValue, dataTypes, true);
}
protected void mergePropertyGetInputsValues(PropertyDataDefinition oldProp, PropertyDataDefinition newProp) {
import org.openecomp.sdc.be.model.InterfaceDefinition;
import org.openecomp.sdc.be.model.Operation;
import org.openecomp.sdc.be.model.tosca.ToscaFunctions;
-import org.openecomp.sdc.be.tosca.utils.InterfacesOperationsToscaUtil;
+import org.openecomp.sdc.be.tosca.InterfacesOperationsConverter;
import java.util.ArrayList;
import java.util.Arrays;
public static Map<String, List<String>> createMappedInputPropertyDefaultValue(String propertyName) {
Map<String, List<String>> getPropertyMap = new HashMap<>();
List<String> values = new ArrayList<>();
- values.add(InterfacesOperationsToscaUtil.SELF);
+ values.add(InterfacesOperationsConverter.SELF);
if (Objects.nonNull(propertyName) && !propertyName.isEmpty()) {
values.addAll(Arrays.asList(propertyName.split("\\.")));
}
String propertyName) {
Map<String, List<String>> getPropertyMap = new HashMap<>();
List<String> values = new ArrayList<>();
- values.add(InterfacesOperationsToscaUtil.SELF);
+ values.add(InterfacesOperationsConverter.SELF);
values.add(capabilityName);
if (Objects.nonNull(propertyName) && !propertyName.isEmpty()) {
import java.util.Map.Entry;
import java.util.stream.Collectors;
-import static org.openecomp.sdc.be.tosca.utils.InterfacesOperationsToscaUtil.SELF;
+import static org.openecomp.sdc.be.tosca.InterfacesOperationsConverter.SELF;
@Loggable(prepend = true, value = Loggable.DEBUG, trim = false)
@Path("/v1/catalog")
package org.openecomp.sdc.be.tosca;
+import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
+import static org.apache.commons.lang3.StringUtils.isBlank;
+import static org.apache.commons.lang3.StringUtils.isNoneBlank;
+
import com.google.common.collect.Iterables;
import com.google.common.collect.Maps;
import fj.data.Either;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.stream.Collectors;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-
-import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
-import static org.apache.commons.lang3.StringUtils.isBlank;
-import static org.apache.commons.lang3.StringUtils.isNoneBlank;
-
/**
* Allows to convert requirements\capabilities of a component to requirements\capabilities of a substitution mappings section of a tosca template
*
@Autowired
private ToscaOperationFacade toscaOperationFacade;
+ @Autowired
+ private PropertyConvertor propertyConvertor;
public CapabilityRequirementConverter() {}
innerType = prop.getSchema().getProperty().getType();
}
String propValue = prop.getValue() == null ? prop.getDefaultValue() : prop.getValue();
- return PropertyConvertor.getInstance().convertToToscaObject(propertyType, propValue, innerType, dataTypes, false);
+ return propertyConvertor.convertToToscaObject(prop, propValue, dataTypes, false);
}
/**
* Allows to convert requirements of a node type to tosca template requirements representation
if (isNotEmpty(properties)) {
Map<String, ToscaProperty> toscaProperties = new HashMap<>();
for (PropertyDefinition property : properties) {
- ToscaProperty toscaProperty = PropertyConvertor.getInstance().convertProperty(dataTypes, property, PropertyConvertor.PropertyType.CAPABILITY);
+ ToscaProperty toscaProperty = propertyConvertor.convertProperty(dataTypes, property, PropertyConvertor.PropertyType.CAPABILITY);
toscaProperties.put(property.getName(), toscaProperty);
}
toscaCapability.setProperties(toscaProperties);
private Map<String, DataTypeDefinition> dataTypes;
private ApplicationDataTypeCache dataTypeCache;
- private PropertyConvertor propertyConvertor = PropertyConvertor.getInstance();
+ private final PropertyConvertor propertyConvertor;
@Autowired
- public GroupExportParserImpl(ApplicationDataTypeCache dataTypeCache) {
+ public GroupExportParserImpl(ApplicationDataTypeCache dataTypeCache, PropertyConvertor propertyConvertor) {
this.dataTypeCache = dataTypeCache;
+ this.propertyConvertor = propertyConvertor;
this.dataTypes = getDataTypes();
}
/*
- * Copyright © 2016-2018 European Support Limited
+ * Copyright © 2016-2020 European Support Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* limitations under the License.
*/
-package org.openecomp.sdc.be.tosca.utils;
+package org.openecomp.sdc.be.tosca;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.openecomp.sdc.be.model.InterfaceDefinition;
import org.openecomp.sdc.be.model.Product;
import org.openecomp.sdc.be.model.tosca.ToscaFunctions;
-import org.openecomp.sdc.be.tosca.PropertyConvertor;
import org.openecomp.sdc.be.tosca.model.ToscaInterfaceDefinition;
import org.openecomp.sdc.be.tosca.model.ToscaInterfaceNodeType;
import org.openecomp.sdc.be.tosca.model.ToscaLifecycleOperationDefinition;
import org.openecomp.sdc.be.tosca.model.ToscaNodeType;
import org.openecomp.sdc.be.tosca.model.ToscaProperty;
+import org.openecomp.sdc.be.tosca.utils.OperationArtifactUtil;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
+@Service
+public class InterfacesOperationsConverter {
-public class InterfacesOperationsToscaUtil {
private static final String DERIVED_FROM_STANDARD_INTERFACE = "tosca.interfaces.node.lifecycle.Standard";
private static final String DERIVED_FROM_BASE_DEFAULT = "org.openecomp.interfaces.node.lifecycle.";
public static final String SELF = "SELF";
private static final String LOCAL_INTERFACE_TYPE = "Local";
- private InterfacesOperationsToscaUtil() {
+ private PropertyConvertor propertyConvertor;
+
+ @Autowired
+ public InterfacesOperationsConverter(PropertyConvertor propertyConvertor) {
+ this.propertyConvertor = propertyConvertor;
}
/**
* @param component to work on
* @param nodeType to which the interfaces element will be added
*/
- public static void addInterfaceDefinitionElement(Component component, ToscaNodeType nodeType,
+ public void addInterfaceDefinitionElement(Component component, ToscaNodeType nodeType,
Map<String, DataTypeDefinition> dataTypes,
boolean isAssociatedComponent) {
if (component instanceof Product) {
}
}
- private static Map<String, Object> getInterfacesMap(Component component,
+ private Map<String, Object> getInterfacesMap(Component component,
Map<String, DataTypeDefinition> dataTypes,
boolean isAssociatedComponent) {
return getInterfacesMap(component, null, component.getInterfaces(), dataTypes, isAssociatedComponent, false);
}
- public static Map<String, Object> getInterfacesMap(Component component,
+ public Map<String, Object> getInterfacesMap(Component component,
ComponentInstance componentInstance,
Map<String, InterfaceDefinition> interfaces,
Map<String, DataTypeDefinition> dataTypes,
return false;
}
- private static void fillToscaOperationInputs(OperationDataDefinition operation,
+ private void fillToscaOperationInputs(OperationDataDefinition operation,
Map<String, DataTypeDefinition> dataTypes,
ToscaLifecycleOperationDefinition toscaOperation,
boolean isServiceProxyInterface) {
if (isServiceProxyInterface) {
String inputValue = Objects.nonNull(input.getValue()) ? getInputValue(input.getValue()) :
getInputValue(input.getToscaDefaultValue());
- toscaInput.setDefaultp(new PropertyConvertor().convertToToscaObject(input.getType(),
- inputValue, input.getSchemaType(), dataTypes, false));
+ toscaInput.setDefaultp(propertyConvertor.convertToToscaObject(input, inputValue, dataTypes, false));
} else {
- toscaInput.setDefaultp(new PropertyConvertor().convertToToscaObject(input.getType(),
- getInputValue(input.getToscaDefaultValue()), input.getSchemaType(), dataTypes, false));
+ toscaInput.setDefaultp(propertyConvertor
+ .convertToToscaObject(input, getInputValue(input.getToscaDefaultValue()),
+ dataTypes, false));
}
toscaInputs.put(input.getName(), toscaInput);
}
private ApplicationDataTypeCache dataTypeCache;
private Map<String, DataTypeDefinition> dataTypes;
- private PropertyConvertor propertyConvertor = PropertyConvertor.getInstance();
+ private PropertyConvertor propertyConvertor;
@Autowired
- public PolicyExportParserImpl(ApplicationDataTypeCache dataTypeCache) {
+ public PolicyExportParserImpl(ApplicationDataTypeCache dataTypeCache, PropertyConvertor propertyConvertor) {
this.dataTypeCache = dataTypeCache;
+ this.propertyConvertor = propertyConvertor;
this.dataTypes = getDataTypes();
}
package org.openecomp.sdc.be.tosca;
-import com.google.gson.Gson;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.google.gson.stream.JsonReader;
import fj.data.Either;
+import java.io.StringReader;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.function.Supplier;
import org.apache.commons.lang3.StringUtils;
import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
import org.openecomp.sdc.be.tosca.model.ToscaNodeType;
import org.openecomp.sdc.be.tosca.model.ToscaProperty;
import org.openecomp.sdc.common.log.wrappers.Logger;
+import org.springframework.stereotype.Service;
-import java.io.StringReader;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.function.Supplier;
-
+@Service
public class PropertyConvertor {
- private static PropertyConvertor instance;
private JsonParser jsonParser = new JsonParser();
private static final Logger log = Logger.getLogger(PropertyConvertor.class);
public enum PropertyType {
INPUT,
PROPERTY
}
- Gson gson = new Gson();
- public PropertyConvertor() {
- }
-
- public static synchronized PropertyConvertor getInstance() {
- if (instance == null) {
- instance = new PropertyConvertor();
- }
- return instance;
- }
public Either<ToscaNodeType, ToscaError> convertProperties(Component component, ToscaNodeType toscaNodeType, Map<String, DataTypeDefinition> dataTypes) {
public ToscaProperty convertProperty(Map<String, DataTypeDefinition> dataTypes, PropertyDefinition property, PropertyType propertyType) {
ToscaProperty prop = new ToscaProperty();
-
- String innerType = null;
+ log.trace("try to convert property {} from type {} with default value [{}]", property.getName(), property.getType(), property.getDefaultValue());
SchemaDefinition schema = property.getSchema();
if (schema != null && schema.getProperty() != null && schema.getProperty().getType() != null && !schema.getProperty().getType().isEmpty()) {
- innerType = schema.getProperty().getType();
EntrySchema eschema = new EntrySchema();
- eschema.setType(innerType);
+ eschema.setType(schema.getProperty().getType());
eschema.setDescription(schema.getProperty().getDescription());
prop.setEntry_schema(eschema);
}
- return getToscaProperty(dataTypes, property, prop, innerType, propertyType);
-
- }
-
- private ToscaProperty getToscaProperty(Map<String, DataTypeDefinition> dataTypes,
- PropertyDataDefinition property,
- ToscaProperty prop,
- String innerType,
- PropertyType propertyType) {
- log.trace("try to convert property {} from type {} with default value [{}]", property.getName(), property.getType(), property.getDefaultValue());
String defaultValue = property.getDefaultValue();
if(Objects.isNull(defaultValue)) {
defaultValue = property.getValue();
}
- Object convertedObj =
- convertToToscaObject(property.getType(), defaultValue, innerType, dataTypes, false);
+ Object convertedObj = convertToToscaObject(property, defaultValue, dataTypes, false);
if (convertedObj != null) {
prop.setDefaultp(convertedObj);
}
}
- public Object convertToToscaObject(String propertyType, String value, String innerType, Map<String, DataTypeDefinition> dataTypes, boolean preserveEmptyValue) {
+ public Object convertToToscaObject(PropertyDataDefinition property, String value, Map<String, DataTypeDefinition> dataTypes, boolean preserveEmptyValue) {
+ String propertyType = property.getType();
+ String innerType = property.getSchemaType();
log.trace("try to convert propertyType {} , value [{}], innerType {}", propertyType, value, innerType);
if (StringUtils.isEmpty(value)) {
value = DataTypePropertyConverter.getInstance().getDataTypePropertiesDefaultValuesRec(propertyType, dataTypes);
try {
ToscaMapValueConverter mapConverterInst = ToscaMapValueConverter.getInstance();
ToscaValueConverter innerConverter = null;
- Boolean isScalar = true;
+ boolean isScalar = true;
ToscaPropertyType type = ToscaPropertyType.isValidType(propertyType);
if (type == null) {
private <T extends PropertyDataDefinition> Object convertValue(Map<String, DataTypeDefinition> dataTypes,
T input, Supplier<String> supplier) {
- String propertyType = input.getType();
- String innerType = null;
- if (input.getSchema() != null && input.getSchema().getProperty() != null) {
- innerType = input.getSchema().getProperty().getType();
- }
- return convertToToscaObject(propertyType, supplier.get(), innerType, dataTypes, false);
+ return convertToToscaObject(input, supplier.get(), dataTypes, false);
}
-
}
package org.openecomp.sdc.be.tosca;
+import static org.apache.commons.collections.CollectionUtils.isEmpty;
+import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
+import static org.apache.commons.collections.MapUtils.isNotEmpty;
+import static org.openecomp.sdc.be.components.utils.PropertiesUtils.resolvePropertyValueFromInput;
+import static org.openecomp.sdc.be.tosca.InterfacesOperationsConverter.addInterfaceTypeElement;
+
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import fj.data.Either;
+import java.beans.IntrospectionException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang.StringUtils;
import org.openecomp.sdc.be.tosca.model.ToscaTopolgyTemplate;
import org.openecomp.sdc.be.tosca.utils.ForwardingPathToscaUtil;
import org.openecomp.sdc.be.tosca.utils.InputConverter;
-import org.openecomp.sdc.be.tosca.utils.InterfacesOperationsToscaUtil;
import org.openecomp.sdc.common.log.wrappers.Logger;
import org.openecomp.sdc.externalupload.utils.ServiceUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.yaml.snakeyaml.representer.Represent;
import org.yaml.snakeyaml.representer.Representer;
-import java.beans.IntrospectionException;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.Set;
-import java.util.function.Supplier;
-import java.util.stream.Collectors;
-
-import static org.apache.commons.collections.CollectionUtils.isEmpty;
-import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
-import static org.apache.commons.collections.MapUtils.isNotEmpty;
-import static org.openecomp.sdc.be.components.utils.PropertiesUtils.resolvePropertyValueFromInput;
-import static org.openecomp.sdc.be.tosca.utils.InterfacesOperationsToscaUtil.addInterfaceDefinitionElement;
-import static org.openecomp.sdc.be.tosca.utils.InterfacesOperationsToscaUtil.addInterfaceTypeElement;
-import static org.openecomp.sdc.be.tosca.utils.ToscaExportUtils.addInputsToProperties;
-import static org.openecomp.sdc.be.tosca.utils.ToscaExportUtils.getProxyNodeTypeInterfaces;
-import static org.openecomp.sdc.be.tosca.utils.ToscaExportUtils.getProxyNodeTypeProperties;
-
@org.springframework.stereotype.Component("tosca-export-handler")
public class ToscaExportHandler {
private PropertyConvertor propertyConvertor;
private InputConverter inputConverter;
private InterfaceLifecycleOperation interfaceLifecycleOperation;
+ private InterfacesOperationsConverter interfacesOperationsConverter;
@Autowired
public ToscaExportHandler(ApplicationDataTypeCache dataTypeCache, ToscaOperationFacade toscaOperationFacade,
- CapabilityRequirementConverter capabilityRequirementConverter, PolicyExportParser policyExportParser,
- GroupExportParser groupExportParser, InputConverter inputConverter, InterfaceLifecycleOperation interfaceLifecycleOperation) {
+ CapabilityRequirementConverter capabilityRequirementConverter, PolicyExportParser policyExportParser,
+ GroupExportParser groupExportParser, PropertyConvertor propertyConvertor, InputConverter inputConverter,
+ InterfaceLifecycleOperation interfaceLifecycleOperation,
+ InterfacesOperationsConverter interfacesOperationsConverter) {
this.dataTypeCache = dataTypeCache;
this.toscaOperationFacade = toscaOperationFacade;
this.capabilityRequirementConverter = capabilityRequirementConverter;
this.policyExportParser = policyExportParser;
this.groupExportParser = groupExportParser;
- this.propertyConvertor = PropertyConvertor.getInstance();
+ this.propertyConvertor = propertyConvertor;
this.inputConverter = inputConverter;
this.interfaceLifecycleOperation = interfaceLifecycleOperation;
+ this.interfacesOperationsConverter = interfacesOperationsConverter;
}
List<InputDefinition> inputDef = component.getInputs();
Map<String, ToscaProperty> mergedProperties = new HashMap<>();
- addInterfaceDefinitionElement(component, toscaNodeType, dataTypes, isAssociatedComponent);
+ interfacesOperationsConverter.addInterfaceDefinitionElement(component, toscaNodeType, dataTypes, isAssociatedComponent);
addInputsToProperties(dataTypes, inputDef, mergedProperties);
if(CollectionUtils.isNotEmpty(component.getProperties())) {
currServiceInterfaces.forEach(instInterface -> tmpInterfaces.put(instInterface
.getUniqueId(), instInterface));
- interfaces = InterfacesOperationsToscaUtil
+ interfaces = interfacesOperationsConverter
.getInterfacesMap(parentComponent, componentInstance, tmpInterfaces, dataTypes, true, true);
}
} else {
if (input.getSchema() != null && input.getSchema().getProperty() != null) {
innerType = input.getSchema().getProperty().getType();
}
- return propertyConvertor.convertToToscaObject(propertyType, supplier.get(), innerType,
- dataTypes, true);
+ return propertyConvertor.convertToToscaObject(input, supplier.get(), dataTypes, true);
}
private ToscaNodeType createNodeType(Component component) {
}
private static class CustomRepresenter extends Representer {
- public CustomRepresenter() {
+ CustomRepresenter() {
super();
// null representer is exceptional and it is stored as an instance
// variable.
Tag customTag) {
if (propertyValue == null) {
return null;
- } else {
- // skip not relevant for Tosca property
- if ("dependencies".equals(property.getName())) {
- return null;
- }
- NodeTuple defaultNode = super.representJavaBeanProperty(javaBean, property, propertyValue, customTag);
-
- return "_defaultp_".equals(property.getName())
- ? new NodeTuple(representData("default"), defaultNode.getValueNode()) : defaultNode;
}
+ // skip not relevant for Tosca property
+ if ("dependencies".equals(property.getName())) {
+ return null;
+ }
+ NodeTuple defaultNode = super.representJavaBeanProperty(javaBean, property, propertyValue, customTag);
+
+ return "_defaultp_".equals(property.getName())
+ ? new NodeTuple(representData("default"), defaultNode.getValueNode()) : defaultNode;
}
@Override
return interfaceObject;
}
+
+ Optional<Map<String, ToscaProperty>> getProxyNodeTypeProperties(Component proxyComponent,
+ Map<String, DataTypeDefinition>
+ dataTypes) {
+ if (Objects.isNull(proxyComponent)) {
+ return Optional.empty();
+ }
+ Map<String, ToscaProperty> proxyProperties = new HashMap<>();
+ addInputsToProperties(dataTypes, proxyComponent.getInputs(), proxyProperties);
+ if (CollectionUtils.isNotEmpty(proxyComponent.getProperties())) {
+ proxyProperties.putAll(proxyComponent.getProperties().stream()
+ .map(propertyDefinition -> resolvePropertyValueFromInput(propertyDefinition,
+ proxyComponent.getInputs()))
+ .collect(Collectors.toMap(PropertyDataDefinition::getName,
+ property -> propertyConvertor.convertProperty(dataTypes, property,
+ PropertyConvertor.PropertyType.PROPERTY))));
+ }
+ return MapUtils.isNotEmpty(proxyProperties) ? Optional.of(proxyProperties) : Optional.empty();
+ }
+
+ void addInputsToProperties(Map<String, DataTypeDefinition> dataTypes,
+ List<InputDefinition> componentInputs,
+ Map<String, ToscaProperty> mergedProperties) {
+ if (CollectionUtils.isEmpty(componentInputs)) {
+ return;
+ }
+ for(InputDefinition input : componentInputs) {
+ ToscaProperty property = propertyConvertor.convertProperty(dataTypes, input,
+ PropertyConvertor.PropertyType.INPUT);
+ mergedProperties.put(input.getName(), property);
+ }
+ }
+
+ Optional<Map<String, Object>> getProxyNodeTypeInterfaces(Component proxyComponent,
+ Map<String, DataTypeDefinition> dataTypes) {
+ if (Objects.isNull(proxyComponent) || MapUtils.isEmpty(proxyComponent.getInterfaces())) {
+ return Optional.empty();
+ }
+ Map<String, InterfaceDefinition> proxyComponentInterfaces = proxyComponent.getInterfaces();
+ //Unset artifact path for operation implementation for proxy node types as for operations with artifacts it is
+ // always available in the proxy node template
+ removeOperationImplementationForProxyNodeType(proxyComponentInterfaces);
+ return Optional.ofNullable(interfacesOperationsConverter
+ .getInterfacesMap(proxyComponent, null, proxyComponentInterfaces, dataTypes,
+ false, false));
+ }
+
+ private static void removeOperationImplementationForProxyNodeType(
+ Map<String, InterfaceDefinition> proxyComponentInterfaces) {
+ if (MapUtils.isEmpty(proxyComponentInterfaces)) {
+ return;
+ }
+ proxyComponentInterfaces.values().stream().map(InterfaceDataDefinition::getOperations)
+ .filter(MapUtils::isNotEmpty)
+ .forEach(operations -> operations.values().forEach(operation -> operation.setImplementation(null)));
+ }
}
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import org.springframework.beans.factory.annotation.Autowired;
@org.springframework.stereotype.Component
public class InputConverter {
private PropertyConvertor propertyConvertor;
private static final Logger log = Logger.getLogger(ToscaExportHandler.class);
-
- public InputConverter() {
- this.propertyConvertor = PropertyConvertor.getInstance();
-
+ @Autowired
+ public InputConverter(PropertyConvertor propertyConvertor) {
+ this.propertyConvertor = propertyConvertor;
}
+
/**
* This is the converter made for input
* input is derived from properties and is similar to properties
+++ /dev/null
-/*
- * Copyright © 2016-2019 European Support Limited
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.openecomp.sdc.be.tosca.utils;
-
-import org.apache.commons.collections.CollectionUtils;
-import org.apache.commons.collections.MapUtils;
-import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition;
-import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
-import org.openecomp.sdc.be.model.Component;
-import org.openecomp.sdc.be.model.DataTypeDefinition;
-import org.openecomp.sdc.be.model.InputDefinition;
-import org.openecomp.sdc.be.model.InterfaceDefinition;
-import org.openecomp.sdc.be.tosca.PropertyConvertor;
-import org.openecomp.sdc.be.tosca.model.ToscaProperty;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.stream.Collectors;
-
-import static org.openecomp.sdc.be.components.utils.PropertiesUtils.resolvePropertyValueFromInput;
-
-public class ToscaExportUtils {
-
- private ToscaExportUtils() {
- //Hiding implicit default constructor
- }
-
- public static Optional<Map<String, Object>> getProxyNodeTypeInterfaces(Component proxyComponent,
- Map<String, DataTypeDefinition> dataTypes) {
- if (Objects.isNull(proxyComponent) || MapUtils.isEmpty(proxyComponent.getInterfaces())) {
- return Optional.empty();
- }
- Map<String, InterfaceDefinition> proxyComponentInterfaces = proxyComponent.getInterfaces();
- //Unset artifact path for operation implementation for proxy node types as for operations with artifacts it is
- // always available in the proxy node template
- removeOperationImplementationForProxyNodeType(proxyComponentInterfaces);
- return Optional.ofNullable(InterfacesOperationsToscaUtil
- .getInterfacesMap(proxyComponent, null, proxyComponentInterfaces, dataTypes, false, false));
- }
-
- public static Optional<Map<String, ToscaProperty>> getProxyNodeTypeProperties(Component proxyComponent,
- Map<String, DataTypeDefinition>
- dataTypes) {
- if (Objects.isNull(proxyComponent)) {
- return Optional.empty();
- }
- Map<String, ToscaProperty> proxyProperties = new HashMap<>();
- addInputsToProperties(dataTypes, proxyComponent.getInputs(), proxyProperties);
- if (CollectionUtils.isNotEmpty(proxyComponent.getProperties())) {
- proxyProperties.putAll(proxyComponent.getProperties().stream()
- .map(propertyDefinition -> resolvePropertyValueFromInput(propertyDefinition,
- proxyComponent.getInputs()))
- .collect(Collectors.toMap(PropertyDataDefinition::getName,
- property -> PropertyConvertor.getInstance().convertProperty(dataTypes, property,
- PropertyConvertor.PropertyType.PROPERTY))));
- }
- return MapUtils.isNotEmpty(proxyProperties) ? Optional.of(proxyProperties) : Optional.empty();
- }
-
- public static void addInputsToProperties(Map<String, DataTypeDefinition> dataTypes,
- List<InputDefinition> componentInputs,
- Map<String, ToscaProperty> mergedProperties) {
- if (CollectionUtils.isEmpty(componentInputs)) {
- return;
- }
- for(InputDefinition input : componentInputs) {
- ToscaProperty property = new PropertyConvertor().convertProperty(dataTypes, input,
- PropertyConvertor.PropertyType.INPUT);
- mergedProperties.put(input.getName(), property);
- }
- }
-
- private static void removeOperationImplementationForProxyNodeType(Map<String, InterfaceDefinition>
- proxyComponentInterfaces) {
- if (MapUtils.isEmpty(proxyComponentInterfaces)) {
- return;
- }
- proxyComponentInterfaces.values().stream()
- .map(InterfaceDataDefinition::getOperations)
- .filter(MapUtils::isNotEmpty)
- .forEach(operations -> operations.values()
- .forEach(operation -> operation.setImplementation(null)));
- }
-}
* limitations under the License.
*/
package org.openecomp.sdc.be.components.impl.utils;
-
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
package org.openecomp.sdc.be.components.merge.property;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.when;
+
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.collect.Maps;
import fj.data.Either;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.openecomp.sdc.be.model.PropertyDefinition;
import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
-
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.when;
+import org.openecomp.sdc.be.tosca.PropertyConvertor;
@RunWith(MockitoJUnitRunner.class)
public class PropertyDataValueMergeBusinessLogicTest {
public void setUp() throws Exception {
PropertyValueMerger propertyValueMerger = new PropertyValueMerger();
- testInstance = new PropertyDataValueMergeBusinessLogic(propertyValueMerger, applicationDataTypeCache);
+ testInstance = new PropertyDataValueMergeBusinessLogic(propertyValueMerger, applicationDataTypeCache,
+ new PropertyConvertor());
}
@Test
import org.junit.Before;
import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
+import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
import static java.util.Arrays.asList;
import static org.assertj.core.api.Assertions.assertThat;
public class CapabilityRequirementConverterTest {
+ @InjectMocks
+ CapabilityRequirementConverter testSubject;
+
+ @Mock
+ ToscaOperationFacade toscaOperationFacade;
+ @Mock
+ private PropertyConvertor propertyConvertorMock;
+
CapabilityRequirementConverter capabiltyRequirementConvertor = Mockito.spy(new CapabilityRequirementConverter());
ComponentInstance instanceProxy = Mockito.spy( new ComponentInstance() );
ComponentInstance vfInstance = Mockito.spy( new ComponentInstance() );
@Mock
private ApplicationDataTypeCache dataTypeCache;
-
@Mock
private Component component;
+ @Mock
+ private PropertyConvertor propertyConvertor;
@Before
public void setUp() throws Exception {
private void initGroupExportParser() {
when(dataTypeCache.getAll()).thenReturn(Either.left(null));
- groupExportParser = new GroupExportParserImpl(dataTypeCache);
+ groupExportParser = new GroupExportParserImpl(dataTypeCache, propertyConvertor);
}
@Test
public void failToGetAllDataTypes() {
when(dataTypeCache.getAll()).thenReturn(Either.right(null));
- assertThatExceptionOfType(SdcResourceNotFoundException.class).isThrownBy(() -> groupExportParser = new GroupExportParserImpl(dataTypeCache));
+ assertThatExceptionOfType(SdcResourceNotFoundException.class).isThrownBy(() -> groupExportParser = new GroupExportParserImpl(dataTypeCache,
+ propertyConvertor));
}
@Test
property3.setType(ToscaPropertyType.BOOLEAN.getType());
property3.setValue("True");
- dataTypes = new HashMap();
+ dataTypes = new HashMap<>();
DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
- List<PropertyDefinition> properties = new ArrayList();
+ List<PropertyDefinition> properties = new ArrayList<>();
properties.add(property1);
dataTypeDefinition.setProperties(properties);
annotation.setName("Annotation1");
annotation.setDescription("description1");
- List<PropertyDataDefinition> propertiesAnnotation = new ArrayList();
+ List<PropertyDataDefinition> propertiesAnnotation = new ArrayList<>();
propertiesAnnotation.add(property2);
propertiesAnnotation.add(property3);
annotation.setProperties(propertiesAnnotation);
ArrayList<InputDefinition> inputDefList = new ArrayList<> ();
inputDefList.add(inputDefinition);
- inputConverter = new InputConverter();
+ inputConverter = new InputConverter(new PropertyConvertor());
Map<String, ToscaProperty> resultInputs ;
resultInputs = inputConverter.convertInputs(inputDefList,dataTypes);
//verify one Input only
@Mock
private ApplicationDataTypeCache dataTypeCache;
+ @Mock
+ private PropertyConvertor propertyConvertor;
@Mock
private Component component;
public void failToGetAllDataTypes() {
when(dataTypeCache.getAll()).thenReturn(Either.right(null));
- assertThatExceptionOfType(SdcResourceNotFoundException.class).isThrownBy(() -> policiyExportParser = new PolicyExportParserImpl(dataTypeCache));
+ assertThatExceptionOfType(SdcResourceNotFoundException.class).isThrownBy(() -> policiyExportParser = new PolicyExportParserImpl(dataTypeCache,
+ propertyConvertor));
}
@Test
when(dataTypeCache.getAll()).thenReturn(Either.left(null));
when(component.getPolicies()).thenReturn(null);
- policiyExportParser = new PolicyExportParserImpl(dataTypeCache);
+ policiyExportParser = new PolicyExportParserImpl(dataTypeCache, propertyConvertor);
Map<String, ToscaPolicyTemplate> policies = policiyExportParser.getPolicies(component);
assertThat(policies).isEqualTo(null);
}
when(component.getPolicies()).thenReturn(policiesToAdd);
when(component.getComponentInstances()).thenReturn(getComponentInstances());
when(component.getGroups()).thenReturn(getGroups());
- policiyExportParser = new PolicyExportParserImpl(dataTypeCache);
+ policiyExportParser = new PolicyExportParserImpl(dataTypeCache, propertyConvertor);
Map<String, ToscaPolicyTemplate> policies = policiyExportParser.getPolicies(component);
package org.openecomp.sdc.be.tosca;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
import fj.data.Either;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
import org.openecomp.sdc.be.components.utils.PropertyDataDefinitionBuilder;
import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
import org.openecomp.sdc.be.model.DataTypeDefinition;
import org.openecomp.sdc.be.tosca.model.ToscaNodeType;
import org.openecomp.sdc.be.tosca.model.ToscaProperty;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-
+@RunWith(MockitoJUnitRunner.class)
public class PropertyConvertorTest {
private PropertyDefinition property;
- Map<String, DataTypeDefinition> dataTypes;
+ private Map<String, DataTypeDefinition> dataTypes;
+
+ @InjectMocks
+ private PropertyConvertor propertyConvertor;
@Before
public void setUp(){
property = new PropertyDefinition();
property.setName("myProperty");
property.setType(ToscaPropertyType.INTEGER.getType());
- dataTypes = new HashMap();
+ dataTypes = new HashMap<>();
dataTypes.put(property.getName(), new DataTypeDefinition());
}
property.setSchema(schema);
- PropertyConvertor.getInstance().convertProperty(dataTypes, property, PropertyConvertor.PropertyType.PROPERTY);
+ propertyConvertor.convertProperty(dataTypes, property, PropertyConvertor.PropertyType.PROPERTY);
}
@Test
public void convertPropertyWhenValueAndDefaultNull() {
- ToscaProperty prop = PropertyConvertor.getInstance().convertProperty(dataTypes, property, PropertyConvertor.PropertyType.PROPERTY);
+ ToscaProperty prop = propertyConvertor.convertProperty(dataTypes, property, PropertyConvertor.PropertyType.PROPERTY);
assertNotNull(prop);
assertNull(prop.getDefaultp());
}
public void convertPropertyWhenValueNullAndDefaultNotEmpty() {
final String def = "1";
property.setDefaultValue(def);
- ToscaProperty result = PropertyConvertor.getInstance().convertProperty(dataTypes, property, PropertyConvertor.PropertyType.PROPERTY);
+ ToscaProperty result = propertyConvertor.convertProperty(dataTypes, property, PropertyConvertor.PropertyType.PROPERTY);
assertNotNull(result);
assertEquals(Integer.valueOf(def), result.getDefaultp());
}
property1.setDefaultValue("2");
dataTypes.put(property1.getName(), new DataTypeDefinition());
Resource resource = new Resource();
- List<PropertyDefinition> properties = new ArrayList();
+ List<PropertyDefinition> properties = new ArrayList<>();
properties.add(property);
properties.add(property1);
resource.setProperties(properties);
- Either<ToscaNodeType, ToscaError> result = PropertyConvertor.getInstance().convertProperties(resource, new ToscaNodeType(), dataTypes);
+ Either<ToscaNodeType, ToscaError> result = propertyConvertor.convertProperties(resource, new ToscaNodeType(), dataTypes);
assertTrue(result.isLeft());
assertEquals(2, result.left().value().getProperties().size());
int cnt = 0;
- for (Iterator<ToscaProperty> it = result.left().value().getProperties().values().iterator(); it.hasNext(); ) {
- ToscaProperty prop = it.next();
+ for (ToscaProperty prop : result.left().value().getProperties().values()) {
if (prop.getDefaultp() == null) {
cnt++;
}
property.setDefaultValue("1");
dataTypes.put(property1.getName(), new DataTypeDefinition());
Resource resource = new Resource();
- List<PropertyDefinition> properties = new ArrayList();
+ List<PropertyDefinition> properties = new ArrayList<>();
properties.add(property);
properties.add(property1);
resource.setProperties(properties);
- Either<ToscaNodeType, ToscaError> result = PropertyConvertor.getInstance().convertProperties(resource, new ToscaNodeType(), dataTypes);
+ Either<ToscaNodeType, ToscaError> result = propertyConvertor.convertProperties(resource, new ToscaNodeType(), dataTypes);
assertTrue(result.isLeft());
assertEquals(2, result.left().value().getProperties().size());
- for (Iterator<ToscaProperty> it = result.left().value().getProperties().values().iterator(); it.hasNext(); ) {
- ToscaProperty prop = it.next();
+ for (ToscaProperty prop : result.left().value().getProperties().values()) {
assertNotNull(prop.getDefaultp());
}
}
property1.setType(ToscaPropertyType.INTEGER.getType());
dataTypes.put(property1.getName(), new DataTypeDefinition());
Resource resource = new Resource();
- List<PropertyDefinition> properties = new ArrayList();
+ List<PropertyDefinition> properties = new ArrayList<>();
properties.add(property);
properties.add(property1);
resource.setProperties(properties);
- Either<ToscaNodeType, ToscaError> result = PropertyConvertor.getInstance().convertProperties(resource, new ToscaNodeType(), dataTypes);
+ Either<ToscaNodeType, ToscaError> result = propertyConvertor.convertProperties(resource, new ToscaNodeType(), dataTypes);
assertTrue(result.isLeft());
assertEquals(2, result.left().value().getProperties().size());
- for (Iterator<ToscaProperty> it = result.left().value().getProperties().values().iterator(); it.hasNext(); ) {
- ToscaProperty prop = it.next();
+ for (ToscaProperty prop : result.left().value().getProperties().values()) {
assertNull(prop.getDefaultp());
}
}
.setDefaultValue("::")
.setType(ToscaPropertyType.STRING.getType())
.build();
- ToscaProperty toscaProperty = PropertyConvertor.getInstance().convertProperty(Collections.emptyMap(), property1, PropertyConvertor.PropertyType.PROPERTY);
+ ToscaProperty toscaProperty = propertyConvertor.convertProperty(Collections.emptyMap(), property1, PropertyConvertor.PropertyType.PROPERTY);
assertThat(toscaProperty.getDefaultp()).isEqualTo("::");
}
.setDefaultValue("/")
.setType(ToscaPropertyType.STRING.getType())
.build();
- ToscaProperty toscaProperty = PropertyConvertor.getInstance().convertProperty(Collections.emptyMap(), property1, PropertyConvertor.PropertyType.PROPERTY);
+ ToscaProperty toscaProperty = propertyConvertor.convertProperty(Collections.emptyMap(), property1, PropertyConvertor.PropertyType.PROPERTY);
assertThat(toscaProperty.getDefaultp()).isEqualTo("/");
}
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyList;
import static org.mockito.ArgumentMatchers.anyMap;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.Mockito.doReturn;
+import static org.openecomp.sdc.be.tosca.PropertyConvertor.PropertyType.PROPERTY;
import fj.data.Either;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.stream.Collectors;
import mockit.Deencapsulation;
import org.apache.commons.collections.MapUtils;
import org.openecomp.sdc.be.components.BeConfDependentTest;
import org.openecomp.sdc.be.components.utils.PropertyDataDefinitionBuilder;
import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
+import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.ForwardingPathElementDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.ToscaArtifactDataDefinition;
private static final String COMPONENT_INPUT_TYPE = "integer";
private static final String RESOURCE_NAME = "resource";
private static final String TOSCA_VERSION = "tosca_simple_yaml_1_1";
+ private static final Map<String, DataTypeDefinition> DATA_TYPES = new HashMap<>();
@InjectMocks
private ToscaExportHandler testSubject;
@Mock
private GroupExportParser groupExportParser;
+ @Mock
+ private PropertyConvertor propertyConvertor;
+
@Mock
private GroupExportParserImpl groupExportParserImpl;
@Mock
private InterfaceLifecycleOperation interfaceLifecycleOperation;
+ @Mock
+ private InterfacesOperationsConverter interfacesOperationsConverter;
+
@Mock
private PolicyExportParser policyExportParser;
@Before
public void setUpMock() throws Exception {
MockitoAnnotations.initMocks(this);
+ doReturn(new ToscaProperty()).when(propertyConvertor).convertProperty(any(), any(), eq(PROPERTY));
+ doReturn(new HashMap<String, Object>()).when(interfacesOperationsConverter)
+ .getInterfacesMap(any(), isNull(), anyMap(), anyMap(), anyBoolean(), anyBoolean());
}
private Resource getNewResource() {
Assert.assertTrue(result.get("test_art").getFile().equals("test_file"));
Assert.assertTrue(result.get("test_art").getType().equals("test_type"));
}
+
+ @Test
+ public void testGetProxyNodeTypeInterfacesNoInterfaces() {
+ Component service = new Service();
+ Optional<Map<String, Object>> proxyNodeTypeInterfaces =
+ testSubject.getProxyNodeTypeInterfaces(service, DATA_TYPES);
+ Assert.assertFalse(proxyNodeTypeInterfaces.isPresent());
+ }
+
+ @Test
+ public void testGetProxyNodeTypeInterfaces() {
+ Component service = getTestComponent();
+ Optional<Map<String, Object>> proxyNodeTypeInterfaces =
+ testSubject.getProxyNodeTypeInterfaces(service, DATA_TYPES);
+ Assert.assertTrue(proxyNodeTypeInterfaces.isPresent());
+ Map<String, Object> componentInterfaces = proxyNodeTypeInterfaces.get();
+ Assert.assertNotNull(componentInterfaces);
+ }
+
+
+ @Test
+ public void testGetProxyNodeTypePropertiesComponentNull() {
+ Optional<Map<String, ToscaProperty>> proxyNodeTypeProperties =
+ testSubject.getProxyNodeTypeProperties(null, DATA_TYPES);
+ Assert.assertFalse(proxyNodeTypeProperties.isPresent());
+ }
+
+ @Test
+ public void testGetProxyNodeTypePropertiesNoProperties() {
+ Component service = new Service();
+ Optional<Map<String, ToscaProperty>> proxyNodeTypeProperties =
+ testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
+ Assert.assertFalse(proxyNodeTypeProperties.isPresent());
+ }
+
+ @Test
+ public void testGetProxyNodeTypeProperties() {
+ Component service = getTestComponent();
+ service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"),
+ createMockProperty("componentPropInt", null)));
+ Optional<Map<String, ToscaProperty>> proxyNodeTypeProperties =
+ testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
+ Assert.assertTrue(proxyNodeTypeProperties.isPresent());
+ Map<String, ToscaProperty> componentProperties = proxyNodeTypeProperties.get();
+ Assert.assertNotNull(componentProperties);
+ Assert.assertEquals(2, componentProperties.size());
+ }
+
+ @Test
+ public void testAddInputsToPropertiesNoInputs() {
+ Component service = getTestComponent();
+ service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"),
+ createMockProperty("componentPropInt", null)));
+ Optional<Map<String, ToscaProperty>> proxyNodeTypePropertiesResult =
+ testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
+
+ Assert.assertTrue(proxyNodeTypePropertiesResult.isPresent());
+ Map<String, ToscaProperty> proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get();
+ testSubject.addInputsToProperties(DATA_TYPES, null, proxyNodeTypeProperties);
+ Assert.assertNotNull(proxyNodeTypeProperties);
+ Assert.assertEquals(2, proxyNodeTypeProperties.size());
+ testSubject.addInputsToProperties(DATA_TYPES, new ArrayList<>(), proxyNodeTypeProperties);
+ Assert.assertEquals(2, proxyNodeTypeProperties.size());
+ }
+
+ @Test
+ public void testAddInputsToPropertiesWithInputs() {
+ Component service = getTestComponent();
+ service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"),
+ createMockProperty("componentPropInt", null)));
+ service.setInputs(Arrays.asList(createMockInput("componentInputStr1",
+ "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2")));
+ Optional<Map<String, ToscaProperty>> proxyNodeTypePropertiesResult =
+ testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
+
+ Assert.assertTrue(proxyNodeTypePropertiesResult.isPresent());
+ Map<String, ToscaProperty> proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get();
+ testSubject.addInputsToProperties(DATA_TYPES, service.getInputs(), proxyNodeTypeProperties);
+ Assert.assertNotNull(proxyNodeTypeProperties);
+ Assert.assertEquals(4, proxyNodeTypeProperties.size());
+ }
+
+ @Test
+ public void testAddInputsToPropertiesOnlyInputs() {
+ Component service = getTestComponent();
+ service.setInputs(Arrays.asList(createMockInput("componentInputStr1",
+ "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2")));
+ Optional<Map<String, ToscaProperty>> proxyNodeTypePropertiesResult =
+ testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
+
+ Assert.assertTrue(proxyNodeTypePropertiesResult.isPresent());
+ Map<String, ToscaProperty> proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get();
+ testSubject.addInputsToProperties(DATA_TYPES, service.getInputs(), proxyNodeTypeProperties);
+ Assert.assertNotNull(proxyNodeTypeProperties);
+ Assert.assertEquals(2, proxyNodeTypeProperties.size());
+ }
+
+ @Test
+ public void testOperationImplementationInProxyNodeTypeNotPresent() {
+ Component service = getTestComponent();
+ InterfaceDefinition interfaceDefinition =
+ service.getInterfaces().get("normalizedServiceComponentName-interface");
+ interfaceDefinition.setOperations(new HashMap<>());
+ final OperationDataDefinition operation = new OperationDataDefinition();
+ operation.setName("start");
+ operation.setDescription("op description");
+ final ArtifactDataDefinition implementation = new ArtifactDataDefinition();
+ implementation.setArtifactName("createBPMN.bpmn");
+ operation.setImplementation(implementation);
+ interfaceDefinition.getOperations().put(operation.getName(), operation);
+ service.getInterfaces().put("normalizedServiceComponentName-interface", interfaceDefinition);
+ service.setInputs(Arrays.asList(createMockInput("componentInputStr1",
+ "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2")));
+ Optional<Map<String, Object>> proxyNodeTypeInterfaces =
+ testSubject.getProxyNodeTypeInterfaces(service, DATA_TYPES);
+ Assert.assertTrue(proxyNodeTypeInterfaces.isPresent());
+ Map<String, Object> componentInterfaces = proxyNodeTypeInterfaces.get();
+ Assert.assertNotNull(componentInterfaces);
+ }
+
+ private Component getTestComponent() {
+ Component component = new Service();
+ component.setNormalizedName("normalizedServiceComponentName");
+ InterfaceDefinition addedInterface = new InterfaceDefinition();
+ addedInterface.setType("com.some.service.or.other.serviceName");
+ final String interfaceType = "normalizedServiceComponentName-interface";
+ component.setInterfaces(new HashMap<>());
+ component.getInterfaces().put(interfaceType, addedInterface);
+ return component;
+ }
+
+ private PropertyDefinition createMockProperty(String propertyName, String defaultValue){
+ PropertyDefinition propertyDefinition = new PropertyDefinition();
+ propertyDefinition.setName(propertyName);
+ propertyDefinition.setType("string");
+ propertyDefinition.setDefaultValue(defaultValue);
+ return propertyDefinition;
+ }
+
+ private InputDefinition createMockInput(String inputName, String defaultValue){
+ InputDefinition inputDefinition = new InputDefinition();
+ inputDefinition.setName(inputName);
+ inputDefinition.setType("string");
+ inputDefinition.setDefaultValue(defaultValue);
+ return inputDefinition;
+ }
+
}
+++ /dev/null
-/*
- * Copyright © 2016-2019 European Support Limited
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.openecomp.sdc.be.tosca;
-
-import org.junit.Assert;
-import org.junit.Test;
-import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
-import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
-import org.openecomp.sdc.be.model.Component;
-import org.openecomp.sdc.be.model.DataTypeDefinition;
-import org.openecomp.sdc.be.model.InputDefinition;
-import org.openecomp.sdc.be.model.InterfaceDefinition;
-import org.openecomp.sdc.be.model.PropertyDefinition;
-import org.openecomp.sdc.be.model.Service;
-import org.openecomp.sdc.be.tosca.model.ToscaProperty;
-import org.openecomp.sdc.be.tosca.utils.ToscaExportUtils;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Optional;
-
-public class ToscaExportUtilsTest {
-
- private static final Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
-
- @Test
- public void testGetProxyNodeTypeInterfacesNoInterfaces() {
- Component service = new Service();
- Optional<Map<String, Object>> proxyNodeTypeInterfaces =
- ToscaExportUtils.getProxyNodeTypeInterfaces(service, dataTypes);
- Assert.assertFalse(proxyNodeTypeInterfaces.isPresent());
- }
-
- @Test
- public void testGetProxyNodeTypeInterfaces() {
- Component service = getTestComponent();
- Optional<Map<String, Object>> proxyNodeTypeInterfaces =
- ToscaExportUtils.getProxyNodeTypeInterfaces(service, dataTypes);
- Assert.assertTrue(proxyNodeTypeInterfaces.isPresent());
- Map<String, Object> componentInterfaces = proxyNodeTypeInterfaces.get();
- Assert.assertNotNull(componentInterfaces);
- Assert.assertEquals(1, componentInterfaces.size());
- }
-
-
- @Test
- public void testGetProxyNodeTypePropertiesComponentNull() {
- Optional<Map<String, ToscaProperty>> proxyNodeTypeProperties =
- ToscaExportUtils.getProxyNodeTypeProperties(null, dataTypes);
- Assert.assertFalse(proxyNodeTypeProperties.isPresent());
- }
-
- @Test
- public void testGetProxyNodeTypePropertiesNoProperties() {
- Component service = new Service();
- Optional<Map<String, ToscaProperty>> proxyNodeTypeProperties =
- ToscaExportUtils.getProxyNodeTypeProperties(service, dataTypes);
- Assert.assertFalse(proxyNodeTypeProperties.isPresent());
- }
-
- @Test
- public void testGetProxyNodeTypeProperties() {
- Component service = getTestComponent();
- service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"),
- createMockProperty("componentPropInt", null)));
- Optional<Map<String, ToscaProperty>> proxyNodeTypeProperties =
- ToscaExportUtils.getProxyNodeTypeProperties(service, dataTypes);
- Assert.assertTrue(proxyNodeTypeProperties.isPresent());
- Map<String, ToscaProperty> componentProperties = proxyNodeTypeProperties.get();
- Assert.assertNotNull(componentProperties);
- Assert.assertEquals(2, componentProperties.size());
- }
-
- @Test
- public void testAddInputsToPropertiesNoInputs() {
- Component service = getTestComponent();
- service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"),
- createMockProperty("componentPropInt", null)));
- Optional<Map<String, ToscaProperty>> proxyNodeTypePropertiesResult =
- ToscaExportUtils.getProxyNodeTypeProperties(service, dataTypes);
-
- Assert.assertTrue(proxyNodeTypePropertiesResult.isPresent());
- Map<String, ToscaProperty> proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get();
- ToscaExportUtils.addInputsToProperties(dataTypes, null, proxyNodeTypeProperties);
- Assert.assertNotNull(proxyNodeTypeProperties);
- Assert.assertEquals(2, proxyNodeTypeProperties.size());
- ToscaExportUtils.addInputsToProperties(dataTypes, new ArrayList<>(), proxyNodeTypeProperties);
- Assert.assertEquals(2, proxyNodeTypeProperties.size());
- }
-
- @Test
- public void testAddInputsToPropertiesWithInputs() {
- Component service = getTestComponent();
- service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"),
- createMockProperty("componentPropInt", null)));
- service.setInputs(Arrays.asList(createMockInput("componentInputStr1",
- "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2")));
- Optional<Map<String, ToscaProperty>> proxyNodeTypePropertiesResult =
- ToscaExportUtils.getProxyNodeTypeProperties(service, dataTypes);
-
- Assert.assertTrue(proxyNodeTypePropertiesResult.isPresent());
- Map<String, ToscaProperty> proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get();
- ToscaExportUtils.addInputsToProperties(dataTypes, service.getInputs(), proxyNodeTypeProperties);
- Assert.assertNotNull(proxyNodeTypeProperties);
- Assert.assertEquals(4, proxyNodeTypeProperties.size());
- Assert.assertNotNull(proxyNodeTypeProperties.get("componentInputStr1"));
- Assert.assertNotNull(proxyNodeTypeProperties.get("componentInputStr2"));
- }
-
- @Test
- public void testAddInputsToPropertiesOnlyInputs() {
- Component service = getTestComponent();
- service.setInputs(Arrays.asList(createMockInput("componentInputStr1",
- "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2")));
- Optional<Map<String, ToscaProperty>> proxyNodeTypePropertiesResult =
- ToscaExportUtils.getProxyNodeTypeProperties(service, dataTypes);
-
- Assert.assertTrue(proxyNodeTypePropertiesResult.isPresent());
- Map<String, ToscaProperty> proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get();
- ToscaExportUtils.addInputsToProperties(dataTypes, service.getInputs(), proxyNodeTypeProperties);
- Assert.assertNotNull(proxyNodeTypeProperties);
- Assert.assertEquals(2, proxyNodeTypeProperties.size());
- Assert.assertNotNull(proxyNodeTypeProperties.get("componentInputStr1"));
- Assert.assertNotNull(proxyNodeTypeProperties.get("componentInputStr2"));
- }
-
- @Test
- public void testOperationImplementationInProxyNodeTypeNotPresent() {
- Component service = getTestComponent();
- InterfaceDefinition interfaceDefinition =
- service.getInterfaces().get("normalizedServiceComponentName-interface");
- interfaceDefinition.setOperations(new HashMap<>());
- final OperationDataDefinition operation = new OperationDataDefinition();
- operation.setName("start");
- operation.setDescription("op description");
- final ArtifactDataDefinition implementation = new ArtifactDataDefinition();
- implementation.setArtifactName("createBPMN.bpmn");
- operation.setImplementation(implementation);
- interfaceDefinition.getOperations().put(operation.getName(), operation);
- service.getInterfaces().put("normalizedServiceComponentName-interface", interfaceDefinition);
- service.setInputs(Arrays.asList(createMockInput("componentInputStr1",
- "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2")));
- Optional<Map<String, Object>> proxyNodeTypeInterfaces =
- ToscaExportUtils.getProxyNodeTypeInterfaces(service, dataTypes);
- Assert.assertTrue(proxyNodeTypeInterfaces.isPresent());
- Map<String, Object> componentInterfaces = proxyNodeTypeInterfaces.get();
- Assert.assertNotNull(componentInterfaces);
- Assert.assertEquals(1, componentInterfaces.size());
- Map<String, Object> proxyInterfaceDefinition =
- (Map<String, Object>) componentInterfaces.get("serviceName");
- Map<String, Object> startOperationDefinition = (Map<String, Object>) proxyInterfaceDefinition.get("start");
- Assert.assertNotNull(startOperationDefinition);
- Assert.assertNull(startOperationDefinition.get("implementation"));
- }
-
- private Component getTestComponent() {
- Component component = new Service();
- component.setNormalizedName("normalizedServiceComponentName");
- InterfaceDefinition addedInterface = new InterfaceDefinition();
- addedInterface.setType("com.some.service.or.other.serviceName");
- final String interfaceType = "normalizedServiceComponentName-interface";
- component.setInterfaces(new HashMap<>());
- component.getInterfaces().put(interfaceType, addedInterface);
- return component;
- }
-
- private PropertyDefinition createMockProperty(String propertyName, String defaultValue){
- PropertyDefinition propertyDefinition = new PropertyDefinition();
- propertyDefinition.setName(propertyName);
- propertyDefinition.setType("string");
- propertyDefinition.setDefaultValue(defaultValue);
- return propertyDefinition;
- }
-
- private InputDefinition createMockInput(String inputName, String defaultValue){
- InputDefinition inputDefinition = new InputDefinition();
- inputDefinition.setName(inputName);
- inputDefinition.setType("string");
- inputDefinition.setDefaultValue(defaultValue);
- return inputDefinition;
- }
-}
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.junit.MockitoJUnitRunner;
import org.onap.sdc.tosca.services.YamlUtil;
import org.openecomp.sdc.be.DummyConfigurationManager;
import org.openecomp.sdc.be.config.Configuration;
import org.openecomp.sdc.be.model.Service;
import org.openecomp.sdc.be.model.ServiceMetadataDefinition;
import org.openecomp.sdc.be.model.tosca.ToscaFunctions;
+import org.openecomp.sdc.be.tosca.InterfacesOperationsConverter;
+import org.openecomp.sdc.be.tosca.PropertyConvertor;
import org.openecomp.sdc.be.tosca.ToscaExportHandler;
import org.openecomp.sdc.be.tosca.ToscaRepresentation;
import org.openecomp.sdc.be.tosca.model.ToscaNodeType;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-import static org.openecomp.sdc.be.tosca.utils.InterfacesOperationsToscaUtil.SELF;
-import static org.openecomp.sdc.be.tosca.utils.InterfacesOperationsToscaUtil.addInterfaceDefinitionElement;
-import static org.openecomp.sdc.be.tosca.utils.InterfacesOperationsToscaUtil.addInterfaceTypeElement;
-
-public class InterfacesOperationsToscaUtilTest {
+import static org.openecomp.sdc.be.tosca.InterfacesOperationsConverter.SELF;
+import static org.openecomp.sdc.be.tosca.InterfacesOperationsConverter.addInterfaceTypeElement;
+@RunWith(MockitoJUnitRunner.class)
+public class InterfacesOperationsConverterTest {
private static final String MAPPED_PROPERTY_NAME = "mapped_property";
private static final String INPUT_NAME_PREFIX = "input_";
DummyConfigurationManager dummyConfigurationManager = new DummyConfigurationManager();
private static final Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
+ private InterfacesOperationsConverter interfacesOperationsConverter;
@BeforeClass
public static void setUp() {
mapper = new ObjectMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
-
}
+
@Before
- public void beforeTest() {
- when(environmentContext.getDefaultValue()).thenReturn("General_Revenue-Bearing");
- when(dummyConfigurationManager.getConfigurationMock().getEnvironmentContext())
- .thenReturn(environmentContext);
+ public void setUpBeforeTest() {
+ interfacesOperationsConverter =
+ new InterfacesOperationsConverter(new PropertyConvertor());
}
-
@Test
public void addInterfaceTypeElementToResource() {
Component component = new Resource();
final Map<String, Object> interfaceTypeElement =
addInterfaceTypeElement(component, new ArrayList<>());
- ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null);
+ ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null, null,
+ interfacesOperationsConverter);
ToscaTemplate template = new ToscaTemplate("test");
template.setInterface_types(interfaceTypeElement);
final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template);
final Map<String, Object> interfaceTypeElement =
addInterfaceTypeElement(component, new ArrayList<>());
- ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null);
+ ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null, null,
+ interfacesOperationsConverter);
ToscaTemplate template = new ToscaTemplate("testService");
template.setInterface_types(interfaceTypeElement);
final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template);
component.setInterfaces(new HashMap<>());
component.getInterfaces().put(interfaceType, addedInterface);
ToscaNodeType nodeType = new ToscaNodeType();
- addInterfaceDefinitionElement(component, nodeType, dataTypes, false);
+ interfacesOperationsConverter.addInterfaceDefinitionElement(component, nodeType, dataTypes, false);
- ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null);
+ ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null, null,
+ interfacesOperationsConverter);
ToscaTemplate template = new ToscaTemplate(NODE_TYPE_NAME);
Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
nodeTypes.put(NODE_TYPE_NAME, nodeType);
component.setInterfaces(new HashMap<>());
component.getInterfaces().put(interfaceType, addedInterface);
ToscaNodeType nodeType = new ToscaNodeType();
- addInterfaceDefinitionElement(component, nodeType, dataTypes, false);
+ interfacesOperationsConverter.addInterfaceDefinitionElement(component, nodeType, dataTypes, false);
- ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null);
+ ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null, null,
+ interfacesOperationsConverter);
ToscaTemplate template = new ToscaTemplate("testService");
Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
nodeTypes.put(NODE_TYPE_NAME, nodeType);
final String interfaceType = "normalizedComponentName-interface";
component.setInterfaces(new HashMap<>());
component.getInterfaces().put(interfaceType, addedInterface);
- Map<String, Object> interfacesMap = InterfacesOperationsToscaUtil
+ Map<String, Object> interfacesMap = interfacesOperationsConverter
.getInterfacesMap(component, null, component.getInterfaces(), null, false, true);
ToscaNodeType nodeType = new ToscaNodeType();
nodeType.setInterfaces(interfacesMap);
component.setInterfaces(new HashMap<>());
component.getInterfaces().put(interfaceType, addedInterface);
ToscaNodeType nodeType = new ToscaNodeType();
- addInterfaceDefinitionElement(component, nodeType, null, false);
+ interfacesOperationsConverter.addInterfaceDefinitionElement(component, nodeType, null, false);
- ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null);
+ ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null, null,
+ interfacesOperationsConverter);
ToscaTemplate template = new ToscaTemplate("test");
Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
nodeTypes.put("test", nodeType);
component.setInterfaces(new HashMap<>());
component.getInterfaces().put(addedInterfaceType, addedInterface);
ToscaNodeType nodeType = new ToscaNodeType();
- addInterfaceDefinitionElement(component, nodeType, dataTypes, false);
+ interfacesOperationsConverter.addInterfaceDefinitionElement(component, nodeType, dataTypes, false);
- ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null);
+ ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null, null,
+ interfacesOperationsConverter);
ToscaTemplate template = new ToscaTemplate("test");
Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
nodeTypes.put("test", nodeType);
component.getInterfaces().put(secondInterfaceType, secondInterface);
ToscaNodeType nodeType = new ToscaNodeType();
- addInterfaceDefinitionElement(component, nodeType, dataTypes, false);
+ interfacesOperationsConverter.addInterfaceDefinitionElement(component, nodeType, dataTypes, false);
- ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null);
+ ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null, null,
+ interfacesOperationsConverter);
ToscaTemplate template = new ToscaTemplate("test");
Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
nodeTypes.put("test", nodeType);
service.getComponentMetadataDefinition().getMetadataDataDefinition().setSystemName("LocalInterface");
service.setInterfaces(Collections.singletonMap("Local", new InterfaceDefinition("Local", null, new HashMap<>())));
- Map<String, Object> resultMap = InterfacesOperationsToscaUtil.addInterfaceTypeElement(service,
+ Map<String, Object> resultMap = InterfacesOperationsConverter.addInterfaceTypeElement(service,
Collections.singletonList("org.openecomp.interfaces.node.lifecycle.Standard"));
Assert.assertTrue(MapUtils.isNotEmpty(resultMap)
service.setInterfaces(Collections.singletonMap("NotLocal", new InterfaceDefinition("NotLocal", null,
new HashMap<>())));
- Map<String, Object> resultMap = InterfacesOperationsToscaUtil.getInterfacesMap(service, null,
+ Map<String, Object> resultMap = interfacesOperationsConverter.getInterfacesMap(service, null,
service.getInterfaces(), null, false, false);
Assert.assertTrue(MapUtils.isNotEmpty(resultMap)
import java.util.List;
import java.util.Map;
import java.util.Set;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
+@EqualsAndHashCode(callSuper = false)
+@Data
public class PropertyDataDefinition extends ToscaDataDefinition {
private String uniqueId;
this.setIsDeclaredListInput(propertyDataDefinition.getIsDeclaredListInput());
}
- public String getParentPropertyType() {
- return parentPropertyType;
- }
-
- public void setParentPropertyType(String parentPropertyType) {
- this.parentPropertyType = parentPropertyType;
- }
-
- public String getSubPropertyInputPath() {
- return subPropertyInputPath;
- }
-
- public void setSubPropertyInputPath(String subPropertyInputPath) {
- this.subPropertyInputPath = subPropertyInputPath;
- }
-
- public String getInputPath() {
- return inputPath;
- }
-
- public void setInputPath(String inputPath) {
- this.inputPath = inputPath;
- }
-
- public String getName() {
- return name;
- }
-
- public void setName(String name) {
- this.name = name;
- }
-
- public String getValue() {
- return value;
- }
-
- public void setValue(String value) {
- this.value = value;
- }
-
// @Override
public boolean isDefinition() {
return true;
}
- public void setDefinition(boolean definition) {
- this.definition = definition;
- }
-
- public boolean getDefinition() {
- return definition;
- }
-
- public String getType() {
- return type;
- }
-
- public String getDefaultValue() {
- return defaultValue;
- }
-
- public void setDefaultValue(String defaultValue) {
- this.defaultValue = defaultValue;
- }
-
- public void setType(String type) {
- this.type = type;
+ public boolean getDefinition() {
+ return definition;
}
public Boolean isRequired() {
return required;
}
- public void setRequired(Boolean required) {
- this.required = required;
- }
-
- public String getDescription() {
- return description;
- }
-
- public void setDescription(String description) {
- this.description = description;
- }
-
- public boolean isPassword() {
- return password;
- }
-
- public void setPassword(boolean password) {
- this.password = password;
- }
-
- public String getUniqueId() {
- return uniqueId;
- }
-
- public void setUniqueId(String uniqueId) {
- this.uniqueId = uniqueId;
- }
-
- public SchemaDefinition getSchema() {
- return schema;
- }
-
public void setSchemaType(String schemaType) {
if (schema != null && schema.getProperty() != null) {
schema.getProperty().setType(schemaType);
}
}
- public void setSchema(SchemaDefinition entrySchema) {
- this.schema = entrySchema;
- }
-
public String getSchemaType() {
if (schema != null && schema.getProperty() != null) {
return schema.getProperty().getType();
return null;
}
- public String getLabel() {
- return label;
- }
-
- public void setLabel(String label) {
- this.label = label;
- }
-
public Boolean isHidden() {
return hidden;
}
- public void setHidden(Boolean hidden) {
- this.hidden = hidden;
- }
-
public Boolean isImmutable() {
return immutable;
}
- public void setImmutable(Boolean immutable) {
- this.immutable = immutable;
- }
-
public String getParentUniqueId() {
return getOwnerId();
}
setOwnerId(parentUniqueId);
}
- public List<GetInputValueDataDefinition> getGetInputValues() {
- return getInputValues;
- }
-
- public void setGetInputValues(List<GetInputValueDataDefinition> getInputValues) {
- this.getInputValues = getInputValues;
- }
-
public List<GetPolicyValueDataDefinition> safeGetGetPolicyValues() {
return CollectionUtils.isEmpty(getPolicyValues) ? new ArrayList<>() : getPolicyValues;
}
- public List<GetPolicyValueDataDefinition> getGetPolicyValues() {
- return getPolicyValues;
- }
-
- public void setGetPolicyValues(List<GetPolicyValueDataDefinition> getPolicyValues) {
- this.getPolicyValues = getPolicyValues;
- }
-
- public String getStatus() {
- return status;
- }
-
- public void setStatus(String status) {
- this.status = status;
- }
-
- public String getInputId() {
- return inputId;
- }
-
- public void setInputId(String inputId) {
- this.inputId = inputId;
- }
-
- public String getInstanceUniqueId() {
- return instanceUniqueId;
- }
-
- public void setInstanceUniqueId(String instanceUniqueId) {
- this.instanceUniqueId = instanceUniqueId;
- }
-
- public String getPropertyId() {
- return propertyId;
- }
-
- public void setPropertyId(String propertyId) {
- this.propertyId = propertyId;
- }
-
- public Boolean getIsDeclaredListInput() {
- return isDeclaredListInput;
- }
-
- public void setIsDeclaredListInput(Boolean isDeclaredListInput) {
- this.isDeclaredListInput = isDeclaredListInput;
- }
-
- @Override
- public String toString() {
- return "PropertyDataDefinition [uniqueId=" + uniqueId + ", type=" + type + ", required=" + required + ", definition=" + definition + ", defaultValue=" + defaultValue + ", description=" + description + ", schema=" + schema + ", password="
- + password + ", name=" + name + ", value=" + value + ", label=" + label + ", hidden=" + hidden + ", immutable=" + immutable + ", inputPath=" + inputPath + ", status=" + status + ", inputId=" + inputId + ", instanceUniqueId="
- + instanceUniqueId + ", propertyId=" + propertyId + ", parentUniqueId=" + parentUniqueId + ", getInputValues=" + getInputValues + ", isDeclaredListInput=" + isDeclaredListInput
- + ", parentPropertyType=" + parentPropertyType
- + ", subPropertyInputPath=" + subPropertyInputPath + "]";
- }
-
- @Override
- public int hashCode() {
- final int hashingValueDefinition = 1231;
- final int hashingValueNoDefinition = 1237;
- final int prime = 31;
- int result = 1;
- result = prime * result + ((defaultValue == null) ? 0 : defaultValue.hashCode());
- result = prime * result + (definition ? hashingValueDefinition : hashingValueNoDefinition);
- result = prime * result + ((description == null) ? 0 : description.hashCode());
- result = prime * result + (password ? hashingValueDefinition : hashingValueNoDefinition);
- result = prime * result + ((required == null) ? 0 : required.hashCode());
- result = prime * result + ((schema == null) ? 0 : schema.hashCode());
- result = prime * result + ((type == null) ? 0 : type.hashCode());
- result = prime * result + ((uniqueId == null) ? 0 : uniqueId.hashCode());
- result = prime * result + ((parentUniqueId == null) ? 0 : parentUniqueId.hashCode());
- result = prime * result + ((status == null) ? 0 : status.hashCode());
- result = prime * result + ((isDeclaredListInput == null) ? 0 : isDeclaredListInput.hashCode());
- return result;
- }
-
public boolean typeEquals(Object obj) {
if (this == obj) {
return true;
return thisSchemaType.equals(otherSchemaType);
}
- @Override
- public boolean equals(Object obj) {
- if (this == obj) {
- return true;
- }
- if (obj == null) {
- return false;
- }
- if (getClass() != obj.getClass()) {
- return false;
- }
- PropertyDataDefinition other = (PropertyDataDefinition) obj;
- if (defaultValue == null) {
- if (other.defaultValue != null) {
- return false;
- }
- } else if (!defaultValue.equals(other.defaultValue)) {
- return false;
- }
- if (definition != other.definition) {
- return false;
- }
- if (description == null) {
- if (other.description != null) {
- return false;
- }
- } else if (!description.equals(other.description)) {
- return false;
- }
- if (password != other.password) {
- return false;
- }
- if (required == null) {
- if (other.required != null) {
- return false;
- }
- } else if (!required.equals(other.required)) {
- return false;
- }
- if (schema == null) {
- if (other.schema != null) {
- return false;
- }
- } else if (!schema.equals(other.schema)) {
- return false;
- }
- if (type == null) {
- if (other.type != null) {
- return false;
- }
- } else if (!type.equals(other.type)) {
- return false;
- }
- if (parentUniqueId == null) {
- if (other.parentUniqueId != null) {
- return false;
- }
- } else if (!parentUniqueId.equals(other.parentUniqueId)) {
- return false;
- }
- if (uniqueId == null) {
- if (other.uniqueId != null) {
- return false;
- }
- } else if (!uniqueId.equals(other.uniqueId)) {
- return false;
- }
- if (status == null) {
- if (other.status != null) {
- return false;
- }
- } else if (!status.equals(other.status)) {
- return false;
- }
- if (isDeclaredListInput == null) {
- if (other.isDeclaredListInput != null) {
- return false;
- }
- } else if (!isDeclaredListInput.equals(other.isDeclaredListInput)) {
- return false;
- }
- return true;
- }
-
@Override
public Object getToscaPresentationValue(JsonPresentationFields field) {
switch (field) {
Set<Annotation> annotationSet = isNotEmpty(newAnnotations) ? new HashSet<>(newAnnotations) : new HashSet<>();
//We would to prioritize the new valid annotations over the old ones if the same one existed.
if (this.annotations != null) {
- for (Annotation oldInputAnnotation : this.annotations) {
- annotationSet.add(oldInputAnnotation);
- }
+ annotationSet.addAll(this.annotations);
}
this.annotations = new ArrayList<>(annotationSet);
public List<Annotation> getAnnotations() {
return (List<Annotation>) getToscaPresentationValue(JsonPresentationFields.ANNOTATIONS);
}
-
- public List<String> getPropertyConstraints() {
- return propertyConstraints;
- }
-
- public void setPropertyConstraints(List<String> constraints) {
- this.propertyConstraints = constraints;
- }
}
Assert.assertEquals(false, result);
result = testSubject.equals(testSubject);
Assert.assertEquals(true, result);
- result = testSubject.equals(createTestSubject());
+ PropertyDataDefinition other = createTestSubject();
+ result = testSubject.equals(other);
Assert.assertEquals(true, result);
}
Code Review / sdc.git / commitdiff