summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorojasdubey <ojas.dubey@amdocs.com>2019-05-22 21:27:32 +0530
committerOren Kleks <orenkle@amdocs.com>2019-05-23 05:50:24 +0000
commite50b5687b62edbafa12bf3825b0441077c5a4820 (patch)
treebd834fb7659eb6d5d802dec6efa4538eda31589d
parentd00c7d99c6c2a8a4f7929db90a4de1e6bd6c3dfa (diff)
Fix service proxy node type4.0.0-ONAP1.4.1
Added properties, interfaces and requirements of the child service to the node type of proxy in the parent Change-Id: I23bb2ddce6cf621d166ffec3031148860d0f4321 Issue-ID: SDC-2313 Signed-off-by: ojasdubey <ojas.dubey@amdocs.com>
-rw-r--r--catalog-be/src/main/java/org/openecomp/sdc/be/tosca/CapabilityRequirementConverter.java62
-rw-r--r--catalog-be/src/main/java/org/openecomp/sdc/be/tosca/ToscaExportHandler.java146
-rw-r--r--catalog-be/src/main/java/org/openecomp/sdc/be/tosca/utils/ToscaExportUtils.java109
-rw-r--r--catalog-be/src/test/java/org/openecomp/sdc/be/tosca/CapabilityRequirementConverterTest.java124
-rw-r--r--catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java72
-rw-r--r--catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportUtilsTest.java307
6 files changed, 647 insertions, 173 deletions
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/CapabilityRequirementConverter.java b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/CapabilityRequirementConverter.java
index bd797c970b..245eb59301 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/CapabilityRequirementConverter.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/CapabilityRequirementConverter.java
@@ -58,6 +58,7 @@ import static org.apache.commons.lang3.StringUtils.isNoneBlank;
public class CapabilityRequirementConverter {
private static final String NO_CAPABILITIES = "No Capabilities for node type";
+ private static final String NO_REQUIREMENTS = "No Requirements for node type";
private static CapabilityRequirementConverter instance;
private static final Logger logger = Logger.getLogger(CapabilityRequirementConverter.class);
private static final String PATH_DELIMITER = ".";
@@ -84,6 +85,18 @@ public class CapabilityRequirementConverter {
return c.getPreviousName();
}
+ public String buildRequirementNameForComponentInstance(Map<String,Component> componentCache,
+ ComponentInstance componentInstance,
+ RequirementDefinition r) {
+ String prefix = buildCapReqNamePrefix(componentInstance.getNormalizedName());
+ if (ComponentUtilities.isNotUpdatedCapReqName(prefix, r.getName(), r.getPreviousName())) {
+ return buildSubstitutedName(componentCache, r.getName(), r.getPreviousName(), r.getPath(), r.getOwnerId(),
+ componentInstance).left()
+ .orValue(r.getName());
+ }
+ return r.getPreviousName();
+ }
+
private String buildCapReqNamePrefix(String normalizedName) {
return normalizedName + PATH_DELIMITER;
}
@@ -187,6 +200,38 @@ public class CapabilityRequirementConverter {
return result;
}
+ /**
+ * Allows to convert requirements of a server proxy node type to tosca template requirements
+ * @param instanceProxy
+ * @return converted tosca template requirements
+ */
+ List<Map<String, ToscaRequirement>> convertProxyRequirements(Map<String, Component> componentCache,
+ ComponentInstance instanceProxy) {
+ Map<String, List<RequirementDefinition>> requirements = instanceProxy.getRequirements();
+ List<Map<String, ToscaRequirement>> toscaRequirements = new ArrayList<>();
+ if (requirements != null) {
+ requirements.entrySet().stream()
+ .flatMap(e -> e.getValue().stream())
+ .forEach(req -> {
+ ImmutablePair<String, ToscaRequirement> pair = convertProxyRequirement(
+ buildRequirementNameForComponentInstance(componentCache, instanceProxy, req), req);
+ Map<String, ToscaRequirement> requirement = new HashMap<>();
+ requirement.put(pair.left, pair.right);
+ toscaRequirements.add(requirement);
+ });
+ } else {
+ logger.debug(NO_REQUIREMENTS);
+ }
+
+ return toscaRequirements;
+ }
+
+ private ImmutablePair<String, ToscaRequirement> convertProxyRequirement(String requirementName,
+ RequirementDefinition r) {
+ ToscaRequirement toscaRequirement = createToscaRequirement(r);
+ return new ImmutablePair<>(requirementName, toscaRequirement);
+ }
+
private List<Map<String, ToscaRequirement>> convertRequirementsAsList(Map<String, Component> componentsCache, Component component) {
Map<String, List<RequirementDefinition>> requirements = component.getRequirements();
List<Map<String, ToscaRequirement>> toscaRequirements = new ArrayList<>();
@@ -202,7 +247,7 @@ public class CapabilityRequirementConverter {
logger.debug("Finish convert Requirements for node type");
}
} else {
- logger.debug("No Requirements for node type");
+ logger.debug(NO_REQUIREMENTS);
}
return toscaRequirements;
}
@@ -384,6 +429,11 @@ public class CapabilityRequirementConverter {
name = buildReqNamePerOwnerByPath(componentsCache, component, r);
}
logger.debug("the requirement {} belongs to resource {} ", name, component.getUniqueId());
+ ToscaRequirement toscaRequirement = createToscaRequirement(r);
+ return new ImmutablePair<>(name, toscaRequirement);
+ }
+
+ private ToscaRequirement createToscaRequirement(RequirementDefinition r) {
ToscaRequirement toscaRequirement = new ToscaRequirement();
List<Object> occurrences = new ArrayList<>();
@@ -397,8 +447,7 @@ public class CapabilityRequirementConverter {
toscaRequirement.setNode(r.getNode());
toscaRequirement.setCapability(r.getCapability());
toscaRequirement.setRelationship(r.getRelationship());
-
- return new ImmutablePair<>(name, toscaRequirement);
+ return toscaRequirement;
}
/**
@@ -424,17 +473,16 @@ public class CapabilityRequirementConverter {
/**
* Allows to convert capabilities of a server proxy node type to tosca template capabilities
- * @param component
- * @param proxyComponent
* @param instanceProxy
* @param dataTypes
* @return
*/
- public Map<String, ToscaCapability> convertProxyCapabilities(Map<String, Component> componentCache, Component component, Component proxyComponent, ComponentInstance instanceProxy, Map<String, DataTypeDefinition> dataTypes) {
+ public Map<String, ToscaCapability> convertProxyCapabilities(Map<String, Component> componentCache,
+ ComponentInstance instanceProxy,
+ Map<String, DataTypeDefinition> dataTypes) {
Map<String, List<CapabilityDefinition>> capabilities = instanceProxy.getCapabilities();
Map<String, ToscaCapability> toscaCapabilities = new HashMap<>();
if (capabilities != null) {
- boolean isNodeType = ModelConverter.isAtomicComponent(component);
for (Map.Entry<String, List<CapabilityDefinition>> entry : capabilities.entrySet()) {
entry.getValue()
.stream()
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/ToscaExportHandler.java b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/ToscaExportHandler.java
index b6c2adb283..7ca25abe14 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/ToscaExportHandler.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/ToscaExportHandler.java
@@ -45,7 +45,6 @@ import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
import org.openecomp.sdc.be.model.jsontitan.utils.ModelConverter;
import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
-import org.openecomp.sdc.be.model.tosca.ToscaFunctions;
import org.openecomp.sdc.be.model.tosca.converters.ToscaValueBaseConverter;
import org.openecomp.sdc.be.tosca.model.*;
import org.openecomp.sdc.be.tosca.utils.ForwardingPathToscaUtil;
@@ -76,9 +75,12 @@ 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.apache.commons.lang.StringUtils.isNotEmpty;
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;
+import static org.openecomp.sdc.be.tosca.utils.ToscaExportUtils.resolvePropertyDefaultValueFromInput;
@org.springframework.stereotype.Component("tosca-export-handler")
public class ToscaExportHandler {
@@ -224,7 +226,8 @@ public class ToscaExportHandler {
}
toscaNode = importsRes.left().value().left;
Map<String, Component> componentCache = importsRes.left().value().right;
- Either<Map<String, ToscaNodeType>, ToscaError> nodeTypesMapEither = createProxyNodeTypes(componentCache , component );
+ Either<Map<String, ToscaNodeType>, ToscaError> nodeTypesMapEither = createProxyNodeTypes(componentCache,
+ component);
if (nodeTypesMapEither.isRight()) {
log.debug("Failed to fetch normative service proxy resource by tosca name, error {}",
nodeTypesMapEither.right().value());
@@ -235,6 +238,16 @@ public class ToscaExportHandler {
toscaNode.setNode_types(nodeTypesMap);
}
+ Either<Map<String, Object>, ToscaError> proxyInterfaceTypesEither = createProxyInterfaceTypes(component);
+ if (proxyInterfaceTypesEither.isRight()) {
+ log.debug("Failed to populate service proxy local interface types in tosca, error {}",
+ nodeTypesMapEither.right().value());
+ return Either.right(proxyInterfaceTypesEither.right().value());
+ }
+ Map<String, Object> proxyInterfaceTypes = proxyInterfaceTypesEither.left().value();
+ if (MapUtils.isNotEmpty(proxyInterfaceTypes)) {
+ toscaNode.setInterface_types(proxyInterfaceTypes);
+ }
Either<Map<String, DataTypeDefinition>, TitanOperationStatus> dataTypesEither = dataTypeCache.getAll();
if (dataTypesEither.isRight()) {
@@ -545,58 +558,25 @@ public class ToscaExportHandler {
List<InputDefinition> inputDef = component.getInputs();
Map<String, ToscaProperty> mergedProperties = new HashMap<>();
addInterfaceDefinitionElement(component, toscaNodeType, dataTypes, isAssociatedComponent);
- if (inputDef != null) {
- addInputsToProperties(dataTypes, inputDef, mergedProperties);
- }
+ addInputsToProperties(dataTypes, inputDef, mergedProperties);
if(CollectionUtils.isNotEmpty(component.getProperties())) {
List<PropertyDefinition> properties = component.getProperties();
- mergedProperties = properties.stream().collect(Collectors.toMap(
+ Map<String, ToscaProperty> convertedProperties = properties.stream().collect(Collectors.toMap(
PropertyDataDefinition::getName,
property -> propertyConvertor.convertProperty(dataTypes, property,
PropertyConvertor.PropertyType.PROPERTY)));
+ // merge component properties and inputs properties
+ mergedProperties.putAll(convertedProperties);
}
if (MapUtils.isNotEmpty(mergedProperties)) {
- if (Objects.nonNull(inputDef)) {
- resolveDefaultPropertyValue(inputDef, mergedProperties, dataTypes);
- }
+ resolvePropertyDefaultValueFromInput(inputDef, mergedProperties, dataTypes);
toscaNodeType.setProperties(mergedProperties);
}
// Extracted to method for code reuse
return convertReqCapAndTypeName(componentsCache, component, toscaNode, nodeTypes, toscaNodeType, dataTypes);
}
- private void resolveDefaultPropertyValue(List<InputDefinition> inputDef,
- Map<String, ToscaProperty> mergedProperties,
- Map<String, DataTypeDefinition> dataTypes) {
- for (Map.Entry<String, ToscaProperty> mergedPropertyEntry : mergedProperties.entrySet()) {
- ToscaProperty value = mergedPropertyEntry.getValue();
- if (Objects.nonNull(value) && value.getDefaultp() instanceof Map) {
- Map<String, String> valueAsMap = (Map<String, String>) value.getDefaultp();
- String inputName = valueAsMap.get(ToscaFunctions.GET_INPUT.getFunctionName());
- Optional<InputDefinition> matchedInputDefinition = inputDef.stream()
- .filter(componentInput -> componentInput.getName().equals(inputName))
- .findFirst();
- if (matchedInputDefinition.isPresent()) {
- InputDefinition matchedInput = matchedInputDefinition.get();
- Object resolvedDefaultValue = new PropertyConvertor().convertToToscaObject(matchedInput.getType(),
- matchedInput.getDefaultValue(), matchedInput.getSchemaType(), dataTypes, false);
- value.setDefaultp(resolvedDefaultValue);
- mergedProperties.put(mergedPropertyEntry.getKey(), value);
- }
- }
- }
- }
-
- private void addInputsToProperties(Map<String, DataTypeDefinition> dataTypes,
- List<InputDefinition> inputDef,
- Map<String, ToscaProperty> mergedProperties) {
- for(InputDefinition input : inputDef) {
- ToscaProperty property = propertyConvertor.convertProperty(dataTypes, input, PropertyConvertor.PropertyType.INPUT);
- mergedProperties.put(input.getName(), property);
- }
- }
-
private Either<ToscaTemplate, ToscaError> convertReqCapAndTypeName(Map<String, Component> componentsCache, Component component, ToscaTemplate toscaNode,
Map<String, ToscaNodeType> nodeTypes, ToscaNodeType toscaNodeType,
Map<String, DataTypeDefinition> dataTypes) {
@@ -908,7 +888,59 @@ public class ToscaExportHandler {
return toscaNodeType;
}
- private Either<Map<String, ToscaNodeType>, ToscaError> createProxyNodeTypes(Map<String, Component> componentCache ,Component container ) {
+ private Either<Map<String, Object>, ToscaError> createProxyInterfaceTypes(Component container) {
+
+ Map<String, Object> proxyInterfaceTypes = new HashMap<>();
+ Either<Map<String, Object>, ToscaError> res = Either.left(proxyInterfaceTypes);
+ List<ComponentInstance> componentInstances = container.getComponentInstances();
+ if (CollectionUtils.isEmpty(componentInstances)) {
+ return res;
+ }
+ Map<String, ComponentInstance> serviceProxyInstanceList = new HashMap<>();
+ componentInstances.stream()
+ .filter(this::isComponentOfTypeServiceProxy)
+ .forEach(inst -> serviceProxyInstanceList.put(inst.getToscaComponentName(), inst));
+ if (MapUtils.isEmpty(serviceProxyInstanceList)) {
+ return res;
+ }
+ for (Entry<String, ComponentInstance> entryProxy : serviceProxyInstanceList.entrySet()) {
+ Component serviceComponent;
+ ComponentParametersView componentParametersView = new ComponentParametersView();
+ componentParametersView.disableAll();
+ componentParametersView.setIgnoreInterfaces(false);
+ Either<Component, StorageOperationStatus> service = toscaOperationFacade
+ .getToscaElement(entryProxy.getValue().getSourceModelUid(), componentParametersView);
+ if (service.isRight()) {
+ log.debug("Failed to fetch original service component with id {} for instance {}",
+ entryProxy.getValue().getSourceModelUid(), entryProxy.getValue().getName());
+ return Either.right(ToscaError.GENERAL_ERROR);
+ } else {
+ serviceComponent = service.left().value();
+ }
+
+ Either<Map<String, InterfaceDefinition>, StorageOperationStatus> lifecycleTypeEither =
+ interfaceLifecycleOperation.getAllInterfaceLifecycleTypes();
+ if(lifecycleTypeEither.isRight()){
+ log.debug("Failed to retrieve global interface types :", lifecycleTypeEither.right().value());
+ return Either.right(ToscaError.GENERAL_ERROR);
+ }
+
+ List<String> allGlobalInterfaceTypes = lifecycleTypeEither.left().value().values().stream()
+ .map(InterfaceDataDefinition::getType)
+ .collect(Collectors.toList());
+ //Add interface types for local interfaces in the original service component for proxy
+ Map<String, Object> localInterfaceTypes = addInterfaceTypeElement(serviceComponent,
+ allGlobalInterfaceTypes);
+ if (MapUtils.isNotEmpty(localInterfaceTypes)) {
+ proxyInterfaceTypes.putAll(localInterfaceTypes);
+ }
+
+ }
+ return Either.left(proxyInterfaceTypes);
+ }
+
+ private Either<Map<String, ToscaNodeType>, ToscaError> createProxyNodeTypes(Map<String, Component> componentCache,
+ Component container) {
Map<String, ToscaNodeType> nodeTypesMap = new HashMap<>();
Either<Map<String, ToscaNodeType>, ToscaError> res = Either.left(nodeTypesMap);
@@ -931,9 +963,6 @@ public class ToscaExportHandler {
if (serviceProxyInstanceList.isEmpty()) {
return res;
}
- ComponentParametersView filter = new ComponentParametersView(true);
- filter.setIgnoreCapabilities(false);
- filter.setIgnoreComponentInstances(false);
Either<Resource, StorageOperationStatus> serviceProxyOrigin = toscaOperationFacade
.getLatestByName("serviceProxy");
if (serviceProxyOrigin.isRight()) {
@@ -948,6 +977,10 @@ public class ToscaExportHandler {
ComponentParametersView componentParametersView = new ComponentParametersView();
componentParametersView.disableAll();
componentParametersView.setIgnoreCategories(false);
+ componentParametersView.setIgnoreProperties(false);
+ componentParametersView.setIgnoreInputs(false);
+ componentParametersView.setIgnoreInterfaces(false);
+ componentParametersView.setIgnoreRequirements(false);
Either<Component, StorageOperationStatus> service = toscaOperationFacade
.getToscaElement(entryProxy.getValue().getSourceModelUid(), componentParametersView);
if (service.isRight()) {
@@ -956,15 +989,16 @@ public class ToscaExportHandler {
serviceComponent = service.left().value();
}
- ToscaNodeType toscaNodeType = createProxyNodeType(componentCache , origComponent, serviceComponent, entryProxy.getValue());
+ ToscaNodeType toscaNodeType = createProxyNodeType(componentCache, origComponent, serviceComponent,
+ entryProxy.getValue());
nodeTypesMap.put(entryProxy.getKey(), toscaNodeType);
}
return Either.left(nodeTypesMap);
}
- private ToscaNodeType createProxyNodeType(Map<String, Component> componentCache , Component origComponent, Component proxyComponent,
- ComponentInstance instance) {
+ private ToscaNodeType createProxyNodeType(Map<String, Component> componentCache , Component origComponent,
+ Component proxyComponent, ComponentInstance instance) {
ToscaNodeType toscaNodeType = new ToscaNodeType();
String derivedFrom = ((Resource) origComponent).getToscaResourceName();
@@ -975,9 +1009,21 @@ public class ToscaExportHandler {
}
Map<String, DataTypeDefinition> dataTypes = dataTypesEither.left().value();
Map<String, ToscaCapability> capabilities = this.capabilityRequirementConverter
- .convertProxyCapabilities( componentCache ,origComponent, proxyComponent, instance, dataTypes);
+ .convertProxyCapabilities(componentCache, instance, dataTypes);
+
+ if (MapUtils.isNotEmpty(capabilities)) {
+ toscaNodeType.setCapabilities(capabilities);
+ }
+ List<Map<String, ToscaRequirement>> proxyNodeTypeRequirements = this.capabilityRequirementConverter
+ .convertProxyRequirements(componentCache, instance);
+ if (CollectionUtils.isNotEmpty(proxyNodeTypeRequirements)) {
+ toscaNodeType.setRequirements(proxyNodeTypeRequirements);
+ }
+ Optional<Map<String, ToscaProperty>> proxyProperties = getProxyNodeTypeProperties(proxyComponent, dataTypes);
+ proxyProperties.ifPresent(toscaNodeType::setProperties);
- toscaNodeType.setCapabilities(capabilities);
+ Optional<Map<String, Object>> proxyInterfaces = getProxyNodeTypeInterfaces(proxyComponent, dataTypes);
+ proxyInterfaces.ifPresent(toscaNodeType::setInterfaces);
return toscaNodeType;
}
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/utils/ToscaExportUtils.java b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/utils/ToscaExportUtils.java
new file mode 100644
index 0000000000..20e0698276
--- /dev/null
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/utils/ToscaExportUtils.java
@@ -0,0 +1,109 @@
+/*
+ * 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 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 org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.collections.MapUtils;
+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.tosca.ToscaFunctions;
+import org.openecomp.sdc.be.tosca.PropertyConvertor;
+import org.openecomp.sdc.be.tosca.model.ToscaProperty;
+
+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();
+ }
+ return Optional.ofNullable(InterfacesOperationsToscaUtil
+ .getInterfacesMap(proxyComponent, null, proxyComponent.getInterfaces(), 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()
+ .collect(Collectors.toMap(PropertyDataDefinition::getName,
+ property -> PropertyConvertor.getInstance().convertProperty(dataTypes, property,
+ PropertyConvertor.PropertyType.PROPERTY))));
+ }
+ resolvePropertyDefaultValueFromInput(proxyComponent.getInputs(), proxyProperties, dataTypes);
+
+ return MapUtils.isNotEmpty(proxyProperties) ? Optional.of(proxyProperties) : Optional.empty();
+ }
+
+
+ public static void resolvePropertyDefaultValueFromInput(List<InputDefinition> componentInputs,
+ Map<String, ToscaProperty> mergedProperties,
+ Map<String, DataTypeDefinition> dataTypes) {
+ if (MapUtils.isEmpty(mergedProperties) || CollectionUtils.isEmpty(componentInputs)) {
+ return;
+ }
+ for (Map.Entry<String, ToscaProperty> mergedPropertyEntry : mergedProperties.entrySet()) {
+ ToscaProperty value = mergedPropertyEntry.getValue();
+ if (Objects.nonNull(value) && value.getDefaultp() instanceof Map) {
+ Map<String, String> valueAsMap = (Map<String, String>) value.getDefaultp();
+ String inputName = valueAsMap.get(ToscaFunctions.GET_INPUT.getFunctionName());
+ Optional<InputDefinition> matchedInputDefinition = componentInputs.stream()
+ .filter(componentInput -> componentInput.getName().equals(inputName))
+ .findFirst();
+ if (matchedInputDefinition.isPresent()) {
+ InputDefinition matchedInput = matchedInputDefinition.get();
+ Object resolvedDefaultValue = new PropertyConvertor().convertToToscaObject(matchedInput.getType(),
+ matchedInput.getDefaultValue(), matchedInput.getSchemaType(), dataTypes, false);
+ value.setDefaultp(resolvedDefaultValue);
+ mergedProperties.put(mergedPropertyEntry.getKey(), value);
+ }
+ }
+ }
+ }
+
+ 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);
+ }
+ }
+
+}
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/CapabilityRequirementConverterTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/CapabilityRequirementConverterTest.java
index 675c51d635..ff522e15c5 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/CapabilityRequirementConverterTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/CapabilityRequirementConverterTest.java
@@ -1,14 +1,31 @@
+/*
+ * 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 java.util.Iterator;
+
+import org.junit.Assert;
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.elements.PropertyDataDefinition;
-import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
+import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
import org.openecomp.sdc.be.model.CapabilityDefinition;
import org.openecomp.sdc.be.model.Component;
@@ -22,12 +39,11 @@ import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
import org.openecomp.sdc.be.tosca.model.SubstitutionMapping;
import org.openecomp.sdc.be.tosca.model.ToscaNodeTemplate;
-import org.openecomp.sdc.be.tosca.model.ToscaNodeType;
-import org.openecomp.sdc.be.tosca.model.ToscaTemplateCapability;
import fj.data.Either;
import mockit.Deencapsulation;
+import org.openecomp.sdc.be.tosca.model.ToscaRequirement;
import java.util.*;
import java.util.stream.Collectors;
@@ -242,7 +258,103 @@ public class CapabilityRequirementConverterTest {
vfComponent.setComponentInstances(componentInstances);
- testSubject.convertProxyCapabilities(componentsCache, vfComponent, vfComponent, instance, dataTypes);
+ testSubject.convertProxyCapabilities(componentsCache, instance, dataTypes);
+ }
+
+ @Test
+ public void testConvertProxyRequirementsNoRequirements() {
+ Map<String, Component> componentsCache = new HashMap<>();
+
+ List<ComponentInstance> componentInstances = new ArrayList<>();
+ ComponentInstance instance = new ComponentInstance();
+ instance.setUniqueId("id");
+ instance.setComponentUid("componentUid");
+ componentInstances.add(instance);
+
+ vfComponent.setComponentInstances(componentInstances);
+
+ Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
+ Mockito.any(ComponentParametersView.class)))
+ .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
+
+ List<Map<String, ToscaRequirement>> proxyRequirements =
+ testSubject.convertProxyRequirements(componentsCache, instance);
+ Assert.assertEquals(0, proxyRequirements.size());
+ }
+
+ @Test
+ public void testConvertProxyRequirementsNotSubstitutedName() {
+ Map<String, Component> componentsCache = new HashMap<>();
+ RequirementDefinition r = new RequirementDefinition();
+ r.setName("port0.dependency");
+ r.setPreviousName("dependency");
+ r.setCapability("tosca.capabilities.Node");
+ r.setNode("tosca.nodes.Root");
+ r.setRelationship("tosca.relationships.DependsOn");
+ r.setMinOccurrences(RequirementDataDefinition.MIN_OCCURRENCES);
+ r.setMaxOccurrences(RequirementDataDefinition.MAX_OCCURRENCES);
+ r.setOwnerId("id");
+ r.setParentName("parentName");
+
+ Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
+ List<RequirementDefinition> requirementDefinitions = new ArrayList<>();
+ requirementDefinitions.add(r);
+ requirements.put("dependency", requirementDefinitions);
+
+ List<ComponentInstance> componentInstances = new ArrayList<>();
+ ComponentInstance instance = new ComponentInstance();
+ instance.setUniqueId("id");
+ instance.setComponentUid("componentUid");
+ instance.setRequirements(requirements);
+ instance.setNormalizedName("port0");
+ componentInstances.add(instance);
+
+ vfComponent.setComponentInstances(componentInstances);
+
+ Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
+ Mockito.any(ComponentParametersView.class)))
+ .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
+
+ List<Map<String, ToscaRequirement>> proxyRequirements =
+ testSubject.convertProxyRequirements(componentsCache, instance);
+ Map<String, ToscaRequirement> proxyRequirement = proxyRequirements.get(0);
+ Assert.assertEquals("dependency", proxyRequirement.keySet().iterator().next());
+ }
+
+ @Test
+ public void testConvertProxyRequirementsSubstitutedName() {
+ Map<String, Component> componentsCache = new HashMap<>();
+ RequirementDefinition r = new RequirementDefinition();
+ r.setName("dependency");
+ r.setPreviousName("dependency");
+ r.setCapability("tosca.capabilities.Node");
+ r.setNode("tosca.nodes.Root");
+ r.setRelationship("tosca.relationships.DependsOn");
+ r.setMinOccurrences(RequirementDataDefinition.MIN_OCCURRENCES);
+ r.setMaxOccurrences(RequirementDataDefinition.MAX_OCCURRENCES);
+ r.setOwnerId("id");
+ r.setParentName("parentName");
+
+ Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
+ List<RequirementDefinition> requirementDefinitions = new ArrayList<>();
+ requirementDefinitions.add(r);
+ requirements.put("dependency", requirementDefinitions);
+
+ List<ComponentInstance> componentInstances = new ArrayList<>();
+ ComponentInstance instance = new ComponentInstance();
+ instance.setUniqueId("id");
+ instance.setComponentUid("componentUid");
+ instance.setRequirements(requirements);
+ instance.setNormalizedName("port0");
+ componentInstances.add(instance);
+
+ vfComponent.setComponentInstances(componentInstances);
+
+ Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
+ Mockito.any(ComponentParametersView.class)))
+ .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
+
+ testSubject.convertProxyRequirements(componentsCache, instance);
}
@Test
@@ -272,7 +384,7 @@ public class CapabilityRequirementConverterTest {
Mockito.any(ComponentParametersView.class)))
.thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
- testSubject.convertProxyCapabilities(componentsCache, vfComponent, vfComponent, instance, dataTypes);
+ testSubject.convertProxyCapabilities(componentsCache, instance, dataTypes);
}
@Test
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java
index d46d234595..57c8f8eb22 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java
@@ -5,10 +5,10 @@ import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-import java.util.function.Supplier;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Triple;
+import org.junit.Assert;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
@@ -36,6 +36,7 @@ import org.openecomp.sdc.be.model.DataTypeDefinition;
import org.openecomp.sdc.be.model.GroupDefinition;
import org.openecomp.sdc.be.model.GroupInstance;
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.RelationshipInfo;
import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
@@ -764,6 +765,75 @@ public class ToscaExportHandlerTest extends BeConfDependentTest {
}
@Test
+ public void testCreateProxyInterfaceTypesComponentNotFound() throws Exception {
+ Component container = new Service();
+ Either<Map<String, ToscaNodeType>, ToscaError> result;
+ List<ComponentInstance> componentInstances = new ArrayList<>();
+ ComponentInstance instance = new ComponentInstance();
+ instance.setOriginType(OriginTypeEnum.ServiceProxy);
+ instance.setSourceModelUid("targetModelUid");
+ instance.setToscaComponentName("toscaComponentName");
+
+ componentInstances.add(instance);
+ container.setComponentInstances(componentInstances);
+ Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
+ Mockito.any(ComponentParametersView.class)))
+ .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
+ result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
+ Assert.assertTrue(result.isRight());
+
+ }
+
+ @Test
+ public void testCreateProxyInterfaceTypesWhenInterfaceLifecycleFetchFailed() {
+ Component container = new Service();
+ Either<Map<String, ToscaNodeType>, ToscaError> result;
+ List<ComponentInstance> componentInstances = new ArrayList<>();
+ ComponentInstance instance = new ComponentInstance();
+ instance.setOriginType(OriginTypeEnum.ServiceProxy);
+ instance.setSourceModelUid("targetModelUid");
+ instance.setToscaComponentName("toscaComponentName");
+ componentInstances.add(instance);
+ container.setComponentInstances(componentInstances);
+
+ Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
+ Mockito.any(ComponentParametersView.class)))
+ .thenReturn(Either.left(new Resource()));
+ Mockito.when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
+ .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
+ result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
+ Assert.assertTrue(result.isRight());
+ }
+
+ @Test
+ public void testCreateProxyInterfaceTypesPositive() {
+ Component container = new Service();
+ Either<Map<String, ToscaNodeType>, ToscaError> result;
+ List<ComponentInstance> componentInstances = new ArrayList<>();
+ ComponentInstance instance = new ComponentInstance();
+ instance.setOriginType(OriginTypeEnum.ServiceProxy);
+ instance.setSourceModelUid("targetModelUid");
+ instance.setToscaComponentName("toscaComponentName");
+ componentInstances.add(instance);
+ container.setComponentInstances(componentInstances);
+
+ Mockito.when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
+ .thenReturn(Either.left(Collections.emptyMap()));
+
+ Component proxyResource = new Resource();
+ Map<String, InterfaceDefinition> proxyInterfaces = new HashMap<>();
+ proxyInterfaces.put("Local", new InterfaceDefinition("Local", "desc", new HashMap<>()));
+ proxyResource.setInterfaces(proxyInterfaces);
+ Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
+ Mockito.any(ComponentParametersView.class)))
+ .thenReturn(Either.left(proxyResource));
+
+ result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
+ Assert.assertTrue(result.isLeft());
+ Assert.assertEquals(1, result.left().value().size());
+ }
+
+ @Test
public void testCreateProxyNodeTypes() throws Exception {
Map<String, Component> componentCache = new HashMap<>();
Component container = new Resource();
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportUtilsTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportUtilsTest.java
index efc89a9f9d..87cc6e8d20 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportUtilsTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportUtilsTest.java
@@ -1,120 +1,209 @@
+/*
+ * 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 com.google.gson.Gson;
-import com.google.gson.GsonBuilder;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import org.junit.Assert;
import org.junit.Test;
-import org.openecomp.sdc.be.components.impl.ComponentInstanceBusinessLogic;
-import org.openecomp.sdc.be.model.operations.impl.ComponentInstanceOperation;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
+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;
public class ToscaExportUtilsTest {
- private static final Logger log = LoggerFactory.getLogger(ToscaExportUtilsTest.class);
- @javax.annotation.Resource
- private ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
- @Autowired
- private ToscaExportHandler exportUtils;
- @Autowired
- private ComponentInstanceOperation componentInstanceOperation;
- Gson gson = new GsonBuilder().setPrettyPrinting().create();
+ 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 testExportService() {
- /* Resource resource1 = ResourceTestUtils.prepareResource(0);
- resource1.setResourceType(ResourceTypeEnum.VF);
- Either<Resource, ResponseFormat> createResource1 = resourceBusinessLogic.createResource(resource1, getAdminUser(), null, null);
- assertTrue(createResource1.isLeft());
- Resource certifiedVFC1 = changeResourceStateToCertify(createResource1.left().value());
-
- Resource resource2 = ResourceTestUtils.prepareResource(1);
- resource2.setResourceType(ResourceTypeEnum.VF);
- Either<Resource, ResponseFormat> createResource2 = resourceBusinessLogic.createResource(resource2, getAdminUser(), null, null);
- assertTrue(createResource2.isLeft());
- Resource certifiedVFC2 = changeResourceStateToCertify(createResource2.left().value());
-
- Service service = ResourceTestUtils.prepareService(0);
- Either<Service, ResponseFormat> createService = serviceBusinessLogic.createService(service, getAdminUser());
- assertTrue(createService.isLeft());
-
- // add VFC instance to VF
- ComponentInstance vfcResourceInstance1 = new ComponentInstance();
- vfcResourceInstance1.setDescription("VFC instance 1");
- vfcResourceInstance1.setName(certifiedVFC1.getName());
- vfcResourceInstance1.setComponentUid(certifiedVFC1.getUniqueId());
-
- Either<ComponentInstance, ResponseFormat> createResourceVfcInstance1 = serviceInstanceBusinessLogic.createComponentInstance(ComponentTypeEnum.SERVICE_PARAM_NAME, createService.left().value().getUniqueId(), adminUser.getAttuid(),
- vfcResourceInstance1);
- assertTrue(createResourceVfcInstance1.isLeft());
-
- ComponentInstance vfcResourceInstance2 = new ComponentInstance();
- vfcResourceInstance2.setDescription("VFC instance 2");
- vfcResourceInstance2.setName(certifiedVFC2.getName());
- vfcResourceInstance2.setComponentUid(certifiedVFC2.getUniqueId());
- Either<ComponentInstance, ResponseFormat> createResourceVfcInstance2 = serviceInstanceBusinessLogic.createComponentInstance(ComponentTypeEnum.SERVICE_PARAM_NAME, createService.left().value().getUniqueId(), adminUser.getAttuid(),
- vfcResourceInstance2);
- assertTrue(createResourceVfcInstance2.isLeft());
-
- Either<Service, ResponseFormat> serviceFetch = serviceBusinessLogic.getService(createService.left().value().getUniqueId(), adminUser);
- assertTrue(serviceFetch.isLeft());
-
- List<ComponentInstance> componentInstances = serviceFetch.left().value().getComponentInstances();
- String ciname1 = null;
- String ciname2 = null;
-
- for (ComponentInstance ci : componentInstances) {
- if (ci.getComponentUid().equals(certifiedVFC1.getUniqueId())) {
- ciname1 = ci.getName();
- }
- if (ci.getComponentUid().equals(certifiedVFC2.getUniqueId())) {
- ciname2 = ci.getName();
- }
- }
-
- Either<ToscaRepresentation, ToscaError> result = exportUtils.exportComponent(serviceFetch.left().value());
- assertTrue(result.isLeft());
-
- String mainYaml = result.left().value().getMainYaml();
- assertNotNull(mainYaml);
-
- YamlToObjectConverter yamlToObjectConverter = new YamlToObjectConverter();
- assertTrue(yamlToObjectConverter.isValidYaml(mainYaml.getBytes()));
- log.debug(mainYaml);
-
- Yaml yaml = new Yaml();
-
- InputStream inputStream = new ByteArrayInputStream(mainYaml.getBytes());
- Map<String, Object> load = (Map<String, Object>) yaml.load(inputStream);
- Map<String, Object> imports = (Map<String, Object>) load.get("imports");
- assertNotNull(imports);
- assertEquals("Validate imports size in yml", 2, imports.size());
-
- Map<String, Object> metadata = (Map<String, Object>) load.get("metadata");
- assertNotNull(metadata);
- validateMetadata(metadata, serviceFetch.left().value(), false);
-
- Map<String, Object> vf1 = (Map<String, Object>) imports.get(certifiedVFC1.getName());
- String fileName = (String) vf1.get(ToscaExportHandler.IMPORTS_FILE_KEY);
- ArtifactDefinition artifactDefinition = certifiedVFC1.getToscaArtifacts().get(ToscaExportHandler.ASSET_TOSCA_TEMPLATE);
- assertEquals("Validate 1 file name", artifactDefinition.getArtifactName(), fileName);
-
- Map<String, Object> topology_template = (Map<String, Object>) load.get("topology_template");
- Map<String, Object> node_templates = (Map<String, Object>) topology_template.get("node_templates");
- Map<String, Object> inst1 = (Map<String, Object>) node_templates.get(ciname1);
- Map<String, Object> inst2 = (Map<String, Object>) node_templates.get(ciname2);
-
- Map<String, Object> inst1MD = (Map<String, Object>) inst1.get("metadata");
- Map<String, Object> inst2MD = (Map<String, Object>) inst2.get("metadata");
-
- validateMetadata(inst1MD, certifiedVFC1, true);
-
- Map<String, Object> vf2 = (Map<String, Object>) imports.get(certifiedVFC2.getName());
- fileName = (String) vf2.get(ToscaExportHandler.IMPORTS_FILE_KEY);
- artifactDefinition = certifiedVFC2.getToscaArtifacts().get(ToscaExportHandler.ASSET_TOSCA_TEMPLATE);
- assertEquals("Validate 2 file name", artifactDefinition.getArtifactName(), fileName);
-
- validateMetadata(inst2MD, certifiedVFC2, true);*/
+ public void testResolvePropertyDefaultValueFromInputNoInputs() {
+ Component service = getTestComponent();
+ service.setProperties(Collections.singletonList(createMockProperty("componentPropStr", null)));
+ Optional<Map<String, ToscaProperty>> properties = ToscaExportUtils.getProxyNodeTypeProperties(service,
+ dataTypes);
+ Assert.assertTrue(properties.isPresent());
+ Map<String, ToscaProperty> nodeTypeProperties = properties.get();
+ ToscaExportUtils.resolvePropertyDefaultValueFromInput(null, nodeTypeProperties, dataTypes);
+ nodeTypeProperties.values().forEach(val -> Assert.assertNull(val.getDefaultp()));
}
+ @Test
+ public void testResolvePropertyDefaultValueFromInput() {
+ Component service = getTestComponent();
+ service.setProperties(Arrays.asList(createMockProperty("componentPropStr1", "{get_input: componentInputStr1}"),
+ createMockProperty("componentPropStr2", "Default prop value"),
+ createMockProperty("componentPropStr3", null)));
+ Optional<Map<String, ToscaProperty>> properties = ToscaExportUtils.getProxyNodeTypeProperties(service,
+ dataTypes);
+ Assert.assertTrue(properties.isPresent());
+ Map<String, ToscaProperty> nodeTypeProperties = properties.get();
+ List<InputDefinition> componentInputs = Arrays.asList(createMockInput("componentInputStr1",
+ "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2"));
+ ToscaExportUtils.resolvePropertyDefaultValueFromInput(componentInputs, nodeTypeProperties, dataTypes);
+ nodeTypeProperties.entrySet().stream()
+ .filter(entry -> entry.getKey().equals("componentPropStr1"))
+ .forEach(entry -> Assert.assertEquals("Default String Input1",
+ entry.getValue().getDefaultp().toString()));
+
+ nodeTypeProperties.entrySet().stream()
+ .filter(entry -> entry.getKey().equals("componentPropStr2"))
+ .forEach(entry -> Assert.assertEquals("Default prop value",
+ entry.getValue().getDefaultp().toString()));
+
+ nodeTypeProperties.entrySet().stream()
+ .filter(entry -> entry.getKey().equals("componentPropStr3"))
+ .forEach(entry -> Assert.assertNull(entry.getValue().getDefaultp()));
+ }
+
+ @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"));
+ }
+
+ 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;
+ }
}