package org.openecomp.sdc.be.components.utils;
+import java.util.List;
import java.util.Map;
import java.util.Optional;
+
+import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.MapUtils;
+import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.InputDefinition;
import org.openecomp.sdc.be.model.InterfaceDefinition;
import org.openecomp.sdc.be.model.Operation;
.filter(entry -> entry.getValue().getUniqueId().equals(operationId)).findAny();
}
+ public static boolean isOperationInputMappedToComponentProperty(OperationInputDefinition input,
+ List<InputDefinition> inputs) {
+ if (CollectionUtils.isEmpty(inputs)) {
+ return false;
+ }
+ return inputs.stream().anyMatch(inp -> inp.getUniqueId().equals(input.getInputId()))
+ || (input.getInputId().contains(".")
+ && inputs.stream().anyMatch(inp -> inp.getUniqueId().equals(
+ input.getInputId().substring(0, input.getInputId().lastIndexOf('.'))))) ;
+ }
+
+
}
package org.openecomp.sdc.be.components.validation;
+import static org.openecomp.sdc.be.components.utils.InterfaceOperationUtils.isOperationInputMappedToComponentProperty;
+
+import com.google.common.collect.Sets;
import fj.data.Either;
+import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Optional;
import java.util.Set;
import java.util.regex.Pattern;
+import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang.StringUtils;
import org.openecomp.sdc.be.components.impl.ResponseFormatManager;
import org.openecomp.sdc.be.dao.api.ActionStatus;
+import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
-import org.openecomp.sdc.be.model.InputDefinition;
+import org.openecomp.sdc.be.datatypes.elements.OperationOutputDefinition;
import org.openecomp.sdc.be.model.InterfaceDefinition;
import org.openecomp.sdc.be.model.Operation;
import org.openecomp.sdc.exception.ResponseFormat;
private static final Logger LOGGER = LoggerFactory.getLogger(InterfaceOperationValidation.class);
- public Either<Boolean, ResponseFormat> validateInterfaceOperations(InterfaceDefinition inputInterfaceDefinition,
- org.openecomp.sdc.be.model.Component component, InterfaceDefinition storedInterfaceDefinition,
- Map<String, InterfaceDefinition> globalInterfaceTypes, boolean isUpdate) {
+ public Either<Boolean, ResponseFormat> validateInterfaceOperations(
+ InterfaceDefinition inputInterfaceDefinition, org.openecomp.sdc.be.model.Component component,
+ InterfaceDefinition storedInterfaceDefinition, Map<String, InterfaceDefinition> globalInterfaceTypes,
+ boolean isUpdate) {
Either<Boolean, ResponseFormat> validateAllowedOperationCountOnLocalInterfaceType =
validateAllowedOperationCountOnLocalInterfaceType(inputInterfaceDefinition, storedInterfaceDefinition,
}
for (Operation interfaceOperation : inputInterfaceDefinition.getOperationsMap().values()) {
- Either<Boolean, ResponseFormat> interfaceOperationValidatorResponse =
- validateInterfaceOperation(interfaceOperation, storedInterfaceDefinition, component, isUpdate);
+ Either<Boolean, ResponseFormat> interfaceOperationValidatorResponse = validateInterfaceOperation(
+ interfaceOperation, storedInterfaceDefinition, inputInterfaceDefinition, component, isUpdate);
if (interfaceOperationValidatorResponse.isRight()) {
return interfaceOperationValidatorResponse;
}
boolean isInterfaceTypeExistInGlobalType =
globalInterfaceTypes.values().stream().map(InterfaceDefinition::getType)
- .anyMatch(type -> type.equalsIgnoreCase(inputInterfaceDefinition.getType()));
- if (!isInterfaceTypeExistInGlobalType
- && (inputInterfaceDefinition.getOperations().size() > 1
- || (!isUpdate && storedInterfaceDefinition != null
- && storedInterfaceDefinition.getType()
- .equalsIgnoreCase(inputInterfaceDefinition.getType())))) {
+ .anyMatch(type -> type.equalsIgnoreCase(inputInterfaceDefinition.getType()));
+ if (!isInterfaceTypeExistInGlobalType && (inputInterfaceDefinition.getOperations().size() > 1
+ || (!isUpdate && storedInterfaceDefinition != null
+ && storedInterfaceDefinition.getType().equalsIgnoreCase(inputInterfaceDefinition.getType())))) {
return Either.right(getResponseFormatManager()
- .getResponseFormat(ActionStatus.INTERFACE_OPERATION_INVALID_FOR_LOCAL_TYPE,
- inputInterfaceDefinition.getType()));
+ .getResponseFormat(ActionStatus.INTERFACE_OPERATION_INVALID_FOR_LOCAL_TYPE,
+ inputInterfaceDefinition.getType()));
}
return Either.left(Boolean.TRUE);
InterfaceDefinition interfaceDefinition, Map<String, InterfaceDefinition> globalInterfaceTypes) {
if (globalInterfaceTypes != null) {
- boolean isOperationValidOnGlobalInterfaceType =
- Stream.of(interfaceDefinition)
- .filter(interfaceDef -> globalInterfaceTypes.values().stream().anyMatch(
- interfaceDef1 -> interfaceDef1.getType().equalsIgnoreCase(interfaceDef.getType())))
- .flatMap(interfaceDef -> interfaceDef.getOperationsMap().values().stream()
- .map(Operation::getName))
- .allMatch(operationName -> globalInterfaceTypes.values().stream()
- .flatMap(interfaceDef -> interfaceDef.getOperationsMap()
- .keySet().stream())
- .anyMatch(opName ->
- opName.equalsIgnoreCase(
- operationName)));
+ boolean isOperationValidOnGlobalInterfaceType = Stream.of(interfaceDefinition)
+ .filter(interfaceDef -> globalInterfaceTypes.values().stream().anyMatch(interfaceDef1 ->
+ interfaceDef1.getType().equalsIgnoreCase(interfaceDef.getType())))
+ .flatMap(interfaceDef -> interfaceDef.getOperationsMap().values().stream().map(Operation::getName))
+ .allMatch(operationName -> globalInterfaceTypes.values().stream()
+ .flatMap(interfaceDef -> interfaceDef.getOperationsMap().keySet().stream())
+ .anyMatch(opName -> opName.equalsIgnoreCase(operationName)));
if (!isOperationValidOnGlobalInterfaceType) {
return Either.right(getResponseFormatManager()
- .getResponseFormat(ActionStatus.INTERFACE_OPERATION_INVALID_FOR_GLOBAL_TYPE,
- interfaceDefinition.getType()));
+ .getResponseFormat(ActionStatus.INTERFACE_OPERATION_INVALID_FOR_GLOBAL_TYPE,
+ interfaceDefinition.getType()));
}
}
return Either.left(Boolean.TRUE);
}
private Either<Boolean, ResponseFormat> validateInterfaceOperation(Operation interfaceOperation,
- InterfaceDefinition interfaceDefinition, org.openecomp.sdc.be.model.Component component, boolean isUpdate) {
+ InterfaceDefinition storedInterfaceDefinition, InterfaceDefinition inputInterfaceDefinition,
+ org.openecomp.sdc.be.model.Component component, boolean isUpdate) {
ResponseFormatManager responseFormatManager = getResponseFormatManager();
Either<Boolean, ResponseFormat> interfaceOperationTypeResponse =
- isInterfaceOperationTypeValid(interfaceOperation, responseFormatManager, interfaceDefinition, isUpdate);
+ isInterfaceOperationTypeValid(interfaceOperation, responseFormatManager, storedInterfaceDefinition,
+ isUpdate);
if (interfaceOperationTypeResponse.isRight()) {
return Either.right(interfaceOperationTypeResponse.right().value());
}
- if (null != interfaceOperation.getInputs()) {
+ if (null != interfaceOperation.getInputs()
+ && CollectionUtils.isNotEmpty(interfaceOperation.getInputs().getListToscaDataDefinition())) {
Either<Boolean, ResponseFormat> inputParametersResponse =
validateInputParameters(interfaceOperation, responseFormatManager);
if (inputParametersResponse.isRight()) {
}
Either<Boolean, ResponseFormat> inputPropertyExistInComponent =
- validateInputPropertyExistInComponent(interfaceOperation, component, responseFormatManager);
+ validateInputPropertyExistInComponent(interfaceOperation,
+ inputInterfaceDefinition, component, responseFormatManager);
if (inputPropertyExistInComponent.isRight()) {
return Either.right(inputPropertyExistInComponent.right().value());
-
}
}
- if (null != interfaceOperation.getOutputs()) {
+ if (null != interfaceOperation.getOutputs()
+ && CollectionUtils.isNotEmpty(interfaceOperation.getOutputs().getListToscaDataDefinition())) {
Either<Boolean, ResponseFormat> outputParametersResponse =
validateOutputParameters(interfaceOperation, responseFormatManager);
if (outputParametersResponse.isRight()) {
}
}
+ if (MapUtils.isNotEmpty(component.getInterfaces()) && isUpdate) {
+ Either<Boolean, ResponseFormat> mappedOutputDeletedResponse =
+ validateMappedOutputNotDeleted(interfaceOperation, component, inputInterfaceDefinition,
+ responseFormatManager);
+ if (mappedOutputDeletedResponse.isRight()) {
+ return Either.right(mappedOutputDeletedResponse.right().value());
+ }
+ }
+
return Either.left(Boolean.TRUE);
}
+
+ private Either<Boolean, ResponseFormat> validateMappedOutputNotDeleted(Operation interfaceOperation,
+ org.openecomp.sdc.be.model.Component component, InterfaceDefinition interfaceDefinition,
+ ResponseFormatManager responseFormatManager) {
+
+ List<OperationOutputDefinition> existingOperationOutputs =
+ getInterfaceOperationOutputs(interfaceOperation.getUniqueId(), component.getInterfaces());
+ if (existingOperationOutputs.isEmpty()) {
+ return Either.left(Boolean.TRUE);
+ }
+ Set<String> existingOperationOutputNames = existingOperationOutputs.stream()
+ .map(OperationOutputDefinition::getName)
+ .collect(Collectors.toSet());
+
+ ListDataDefinition<OperationOutputDefinition> currentOutputs = interfaceOperation.getOutputs();
+ Set<String> currentOperationOutputNames = new HashSet<>();
+ if (currentOutputs != null && !currentOutputs.isEmpty()) {
+ currentOperationOutputNames = currentOutputs.getListToscaDataDefinition().stream()
+ .map(OperationOutputDefinition::getName)
+ .collect(Collectors.toSet());
+ }
+ String mappedOutputPrefix = interfaceDefinition.getType() + "." + interfaceOperation.getName();
+ Set<String> deletedOutputs = Sets.difference(existingOperationOutputNames, currentOperationOutputNames);
+ Set<String> deletedMappedOutputs = deletedOutputs.stream()
+ .filter(deletedOutputName -> isMappedOutputDeleted(mappedOutputPrefix, deletedOutputName,
+ component.getInterfaces()))
+ .map(this::getOperationOutputName)
+ .collect(Collectors.toSet());
+
+ if (CollectionUtils.isNotEmpty(deletedMappedOutputs)) {
+ return getMappedOutputErrorResponse(responseFormatManager, deletedMappedOutputs);
+ }
+ return Either.left(Boolean.TRUE);
+ }
+
+ private boolean isMappedOutputDeleted(String mappedOutputPrefix, String outputName,
+ Map<String, InterfaceDefinition> componentInterfaces) {
+ List<OperationInputDefinition> interfaceOperationInputs =
+ getOtherOperationInputsOfComponent(mappedOutputPrefix, componentInterfaces);
+ return interfaceOperationInputs.stream()
+ .anyMatch(operationInputDefinition -> operationInputDefinition.getInputId()
+ .equals(mappedOutputPrefix + "." + outputName));
+ }
+
+ private Either<Boolean, ResponseFormat> getMappedOutputErrorResponse(ResponseFormatManager responseFormatManager,
+ Set<String> deletedMappedOutputs) {
+ String deletedOutputNameList = String.join(",", deletedMappedOutputs);
+ LOGGER.error("Cannot update name or delete interface operation output(s) '{}' mapped to an operation input",
+ deletedOutputNameList);
+ ResponseFormat errorResponse = responseFormatManager.getResponseFormat(ActionStatus
+ .INTERFACE_OPERATION_MAPPED_OUTPUT_DELETED, deletedOutputNameList);
+ return Either.right(errorResponse);
+ }
+
+
protected ResponseFormatManager getResponseFormatManager() {
return ResponseFormatManager.getInstance();
}
private Either<Boolean, ResponseFormat> isInterfaceOperationTypeValid(Operation interfaceOperation,
- ResponseFormatManager responseFormatManager, InterfaceDefinition interfaceDefinition, boolean isUpdate) {
+ ResponseFormatManager responseFormatManager,
+ InterfaceDefinition interfaceDefinition,
+ boolean isUpdate) {
Either<Boolean, ResponseFormat> operationTypeEmptyEither =
isOperationTypeEmpty(responseFormatManager, interfaceOperation.getName());
return Either.right(operationTypeRegexValidationResponse.right().value());
}
- Either<Boolean, ResponseFormat> operationTypeUniqueResponse =
- validateOperationTypeUnique(interfaceOperation, interfaceDefinition, isUpdate);
+ Either<Boolean, ResponseFormat> operationTypeUniqueResponse = validateOperationTypeUnique(interfaceOperation,
+ interfaceDefinition, isUpdate);
if (operationTypeUniqueResponse.isRight()) {
return Either.right(operationTypeUniqueResponse.right().value());
}
}
private Either<Boolean, ResponseFormat> validateInputParameters(Operation interfaceOperation,
- ResponseFormatManager responseFormatManager) {
+ ResponseFormatManager responseFormatManager) {
if (isInputParameterNameEmpty(interfaceOperation)) {
LOGGER.error("Interface operation input parameter name can't be empty");
ResponseFormat inputResponse =
if (validateInputParametersUniqueResponse.isRight()) {
LOGGER.error("Interface operation input parameter names {} already in use",
validateInputParametersUniqueResponse.right().value());
- ResponseFormat inputResponse = responseFormatManager.getResponseFormat(
- ActionStatus.INTERFACE_OPERATION_INPUT_NAME_ALREADY_IN_USE,
- validateInputParametersUniqueResponse.right().value().toString());
+ ResponseFormat inputResponse =
+ responseFormatManager.getResponseFormat(ActionStatus.INTERFACE_OPERATION_INPUT_NAME_ALREADY_IN_USE,
+ validateInputParametersUniqueResponse.right().value().toString());
return Either.right(inputResponse);
}
return Either.left(Boolean.TRUE);
}
- private Either<Boolean, ResponseFormat> validateInputPropertyExistInComponent(Operation operation,
- org.openecomp.sdc.be.model.Component component, ResponseFormatManager responseFormatManager) {
-
- List<OperationInputDefinition> inputListToscaDataDefinition =
- operation.getInputs().getListToscaDataDefinition();
- for (OperationInputDefinition inputDefinition : inputListToscaDataDefinition) {
- if (!validateInputExistsInComponent(inputDefinition, component.getInputs())) {
- String missingPropertyName = inputDefinition.getInputId().contains(".")
- ? inputDefinition.getInputId().substring(
- inputDefinition.getInputId().indexOf('.') + 1)
- : inputDefinition.getInputId();
- LOGGER.error("Interface operation input property {} not found in component input properties",
- missingPropertyName);
- ResponseFormat inputResponse = responseFormatManager.getResponseFormat(
- ActionStatus.INTERFACE_OPERATION_INPUT_PROPERTY_NOT_FOUND_IN_COMPONENT, missingPropertyName,
- component.getComponentType().getValue());
- return Either.right(inputResponse);
- }
- }
- return Either.left(Boolean.TRUE);
- }
-
private Either<Boolean, ResponseFormat> validateOutputParameters(Operation interfaceOperation,
- ResponseFormatManager responseFormatManager) {
+ ResponseFormatManager responseFormatManager) {
if (isOutputParameterNameEmpty(interfaceOperation)) {
LOGGER.error("Interface operation output parameter name can't be empty");
ResponseFormat inputResponse =
if (validateOutputParametersUniqueResponse.isRight()) {
LOGGER.error("Interface operation output parameter names {} already in use",
validateOutputParametersUniqueResponse.right().value());
- ResponseFormat inputResponse = responseFormatManager.getResponseFormat(
- ActionStatus.INTERFACE_OPERATION_OUTPUT_NAME_ALREADY_IN_USE,
- validateOutputParametersUniqueResponse.right().value().toString());
+ ResponseFormat inputResponse =
+ responseFormatManager.getResponseFormat(ActionStatus.INTERFACE_OPERATION_OUTPUT_NAME_ALREADY_IN_USE,
+ validateOutputParametersUniqueResponse.right().value().toString());
return Either.right(inputResponse);
}
return Either.left(Boolean.TRUE);
inputParam -> inputParam.getName() == null || inputParam.getName().trim().equals(StringUtils.EMPTY));
}
+
private Either<Boolean, Set<String>> isInputParametersUnique(Operation operationDataDefinition) {
Set<String> inputParamNamesSet = new HashSet<>();
Set<String> duplicateParamNamesToReturn = new HashSet<>();
- operationDataDefinition.getInputs().getListToscaDataDefinition().forEach(inputParam -> {
- if (!inputParamNamesSet.add(inputParam.getName().trim())) {
- duplicateParamNamesToReturn.add(inputParam.getName().trim());
- }
- });
+ operationDataDefinition.getInputs().getListToscaDataDefinition()
+ .forEach(inputParam -> {
+ if (!inputParamNamesSet.add(inputParam.getName().trim())) {
+ duplicateParamNamesToReturn.add(inputParam.getName().trim());
+ }
+ });
if (!duplicateParamNamesToReturn.isEmpty()) {
return Either.right(duplicateParamNamesToReturn);
}
return Either.left(Boolean.TRUE);
}
- private boolean validateInputExistsInComponent(OperationInputDefinition input, List<InputDefinition> inputs) {
- return inputs.stream().anyMatch(inp -> inp.getUniqueId().equals(input.getInputId()))
- || (input.getInputId().contains(".")
- && inputs.stream()
- .anyMatch(inp -> inp.getUniqueId()
- .equals(input.getInputId()
- .substring(0,
- input.getInputId()
- .lastIndexOf('.')))));
- }
-
private Boolean isOutputParameterNameEmpty(Operation operationDataDefinition) {
return operationDataDefinition.getOutputs().getListToscaDataDefinition().stream().anyMatch(
outputParam -> outputParam.getName() == null || outputParam.getName().trim().equals(StringUtils.EMPTY));
private Either<Boolean, Set<String>> isOutputParametersUnique(Operation operationDataDefinition) {
Set<String> outputParamNamesSet = new HashSet<>();
Set<String> duplicateParamNamesToReturn = new HashSet<>();
- operationDataDefinition.getOutputs().getListToscaDataDefinition().forEach(outputParam -> {
- if (!outputParamNamesSet.add(outputParam.getName().trim())) {
- duplicateParamNamesToReturn.add(outputParam.getName().trim());
- }
- });
+ operationDataDefinition.getOutputs().getListToscaDataDefinition()
+ .forEach(outputParam -> {
+ if (!outputParamNamesSet.add(outputParam.getName().trim())) {
+ duplicateParamNamesToReturn.add(outputParam.getName().trim());
+ }
+ });
if (!duplicateParamNamesToReturn.isEmpty()) {
return Either.right(duplicateParamNamesToReturn);
}
return Either.left(Boolean.TRUE);
}
+ private Either<Boolean, ResponseFormat> validateInputPropertyExistInComponent(Operation operation,
+ InterfaceDefinition inputInterfaceDefinition, org.openecomp.sdc.be.model.Component component,
+ ResponseFormatManager responseFormatManager) {
+
+ boolean isOperationInputToInputPropertyMappingValid = false;
+ boolean isOperationInputToOtherOperationOutputMappingValid = false;
+ String mappingName = "";
+ List<OperationInputDefinition> inputListToscaDataDefinition =
+ operation.getInputs().getListToscaDataDefinition();
+ for (OperationInputDefinition inputDefinition : inputListToscaDataDefinition) {
+ if (isOperationInputMappedToComponentProperty(inputDefinition, component.getInputs())) {
+ isOperationInputToInputPropertyMappingValid = true;
+ } else {
+ mappingName = inputDefinition.getInputId().contains(".")
+ ? inputDefinition.getInputId().substring(inputDefinition.getInputId().lastIndexOf(".") + 1)
+ : inputDefinition.getInputId();
+ break;
+ }
+ }
+ if (isOperationInputToInputPropertyMappingValid) {
+ return Either.left(Boolean.TRUE);
+ }
+
+ //Mapped property not found in the component properties.. Check in other operation output parameters of
+ // component (other operation => not having the same full name)
+ ListDataDefinition<OperationOutputDefinition> outputListDataDefinition =
+ getOtherOperationOutputsOfComponent(inputInterfaceDefinition.getType(), operation.getName(), component);
+
+ List<OperationOutputDefinition> componentOutputsFromOtherOperations =
+ outputListDataDefinition.getListToscaDataDefinition();
+ if (validateOutputExistsInComponent(mappingName, componentOutputsFromOtherOperations)) {
+ isOperationInputToOtherOperationOutputMappingValid = true;
+ } else {
+ //Get the output parameter display name from the full name
+ mappingName = getOperationOutputName(mappingName);
+ }
+
+ if (!isOperationInputToOtherOperationOutputMappingValid) {
+ LOGGER.error("Interface operation input parameter property {} not found in component input properties or"
+ + " outputs of other operations.", mappingName);
+ ResponseFormat inputResponse = responseFormatManager
+ .getResponseFormat(ActionStatus.INTERFACE_OPERATION_INPUT_PROPERTY_NOT_FOUND_IN_COMPONENT,
+ mappingName, component.getComponentType().getValue());
+ return Either.right(inputResponse);
+ }
+ return Either.left(Boolean.TRUE);
+ }
+
+ private boolean validateOutputExistsInComponent(String mappedOutputName,
+ List<OperationOutputDefinition> outputs) {
+ return outputs.stream()
+ .anyMatch(output -> output.getName().equals(mappedOutputName));
+ }
+
+ /**
+ * Get the list of outputs of other operations of all the interfaces in the component.
+ * @param currentInterfaceName Fully qualified interface name e.g. org.test.interfaces.node.lifecycle.Abc
+ * @param currentOperationName Name entered on the operation screen e.g. create
+ * @param component VF or service
+ */
+
+ private ListDataDefinition<OperationOutputDefinition> getOtherOperationOutputsOfComponent(
+ String currentInterfaceName, String currentOperationName, org.openecomp.sdc.be.model.Component component) {
+ ListDataDefinition<OperationOutputDefinition> componentOutputs = new ListDataDefinition<>();
+ Map<String, InterfaceDefinition> componentInterfaces = component.getInterfaces();
+ if (MapUtils.isEmpty(componentInterfaces)) {
+ return componentOutputs;
+ }
+ for (Map.Entry<String, InterfaceDefinition> interfaceDefinitionEntry : componentInterfaces.entrySet()) {
+ String interfaceName = interfaceDefinitionEntry.getKey();
+ final Map<String, OperationDataDefinition> operations = interfaceDefinitionEntry.getValue().getOperations();
+ if (MapUtils.isEmpty(operations)) {
+ continue;
+ }
+ String actualOperationIdentifier = currentInterfaceName + "." + currentOperationName;
+ for (Map.Entry<String, OperationDataDefinition> operationEntry : operations.entrySet()) {
+ ListDataDefinition<OperationOutputDefinition> outputs = operationEntry.getValue().getOutputs();
+ String expectedOperationIdentifier = interfaceName + "." + operationEntry.getKey();
+ if (!actualOperationIdentifier.equals(expectedOperationIdentifier) && !outputs.isEmpty()) {
+ outputs.getListToscaDataDefinition().forEach(componentOutputs::add);
+ }
+ }
+ }
+ return componentOutputs;
+ }
+
+ /**
+ * Get the input definitions of other operations of the component from current as well as other interfaces.
+ * @param currentOperationIdentifier Identifier for the request operation (interface_name.operation_name)
+ * @param componentInterfaces Interfaces of the component
+ */
+ private List<OperationInputDefinition> getOtherOperationInputsOfComponent(String currentOperationIdentifier,
+ Map<String, InterfaceDefinition>
+ componentInterfaces) {
+ List<OperationInputDefinition> otherOperationInputs = new ArrayList<>();
+ if (MapUtils.isEmpty(componentInterfaces)) {
+ return otherOperationInputs;
+ }
+ for (Map.Entry<String, InterfaceDefinition> interfaceDefinitionEntry : componentInterfaces.entrySet()) {
+ final Map<String, OperationDataDefinition> operations = interfaceDefinitionEntry.getValue().getOperations();
+ if (MapUtils.isEmpty(operations)) {
+ continue;
+ }
+ for (Map.Entry<String, OperationDataDefinition> operationEntry : operations.entrySet()) {
+ ListDataDefinition<OperationInputDefinition> inputs = operationEntry.getValue().getInputs();
+ String expectedOperationIdentifier =
+ interfaceDefinitionEntry.getValue().getType() + "." + operationEntry.getValue().getName();
+ if (!currentOperationIdentifier.equals(expectedOperationIdentifier) && !inputs.isEmpty()) {
+ otherOperationInputs.addAll(inputs.getListToscaDataDefinition());
+ }
+ }
+ }
+ return otherOperationInputs;
+ }
+
+ private String getOperationOutputName(String outputName) {
+ return outputName.contains(".")
+ ? outputName.substring(outputName.lastIndexOf(".") + 1)
+ : outputName;
+ }
+
+ /**
+ * Get the output of an operation in an interface.
+ * @param inputOperationId Unique identifier for the request operation
+ * @param componentInterfaces Interfaces of the component
+ */
+ private List<OperationOutputDefinition> getInterfaceOperationOutputs(String inputOperationId,
+ Map<String, InterfaceDefinition>
+ componentInterfaces) {
+ List<OperationOutputDefinition> operationOutputDefinitions = new ArrayList<>();
+ if (MapUtils.isEmpty(componentInterfaces)) {
+ return operationOutputDefinitions;
+ }
+ for (Map.Entry<String, InterfaceDefinition> interfaceDefinitionEntry : componentInterfaces.entrySet()) {
+ final Map<String, OperationDataDefinition> operations = interfaceDefinitionEntry.getValue().getOperations();
+ if (MapUtils.isEmpty(operations)) {
+ continue;
+ }
+ for (Map.Entry<String, OperationDataDefinition> operationEntry : operations.entrySet()) {
+ String expectedOperationId = operationEntry.getValue().getUniqueId();
+ if (expectedOperationId.equals(inputOperationId)) {
+ ListDataDefinition<OperationOutputDefinition> operationOutputs =
+ operationEntry.getValue().getOutputs();
+ return (Objects.isNull(operationOutputs) || operationOutputs.isEmpty())
+ ? operationOutputDefinitions
+ : operationOutputs.getListToscaDataDefinition();
+ }
+ }
+ }
+ return operationOutputDefinitions;
+ }
+
private boolean isValidOperationType(String operationType) {
return Pattern.matches(TYPE_VALIDATION_REGEX, operationType);
}
package org.openecomp.sdc.be.tosca.utils;
+import static org.openecomp.sdc.be.components.utils.InterfaceOperationUtils.isOperationInputMappedToComponentProperty;
+
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.ObjectMapper;
private static final String DEFAULT = "default";
private static final String DEFAULT_HAS_UNDERSCORE = "_default";
private static final String DOT = ".";
- private static final String SELF = "SELF";
- private static final String GET_PROPERTY = "get_property";
private static final String DEFAULTP = "defaultp";
+ static final String SELF = "SELF";
+ static final String GET_PROPERTY = "get_property";
+ static final String GET_OPERATION_OUTPUT = "get_operation_output";
+
private InterfacesOperationsToscaUtil() {
}
toscaOperation.setImplementation(operationArtifactPath);
}
toscaOperation.setDescription(operationEntry.getValue().getDescription());
- fillToscaOperationInputs(operationEntry.getValue(), toscaOperation);
+ fillToscaOperationInputs(operationEntry.getValue(), toscaOperation, interfaceType, component);
toscaOperations.put(operationEntry.getValue().getName(), toscaOperation);
}
}
private static void fillToscaOperationInputs(OperationDataDefinition operation,
- ToscaLifecycleOperationDefinition toscaOperation) {
+ ToscaLifecycleOperationDefinition toscaOperation,
+ String interfaceType,
+ Component component) {
if (Objects.isNull(operation.getInputs()) || operation.getInputs().isEmpty()) {
toscaOperation.setInputs(null);
return;
for (OperationInputDefinition input : operation.getInputs().getListToscaDataDefinition()) {
ToscaProperty toscaInput = new ToscaProperty();
toscaInput.setDescription(input.getDescription());
- String mappedPropertyName = null;
+ String mappedPropertyName;
if (Objects.nonNull(input.getInputId())) {
- mappedPropertyName = input.getInputId().substring(input.getInputId().indexOf(DOT) + 1);
+ if (isOperationInputMappedToComponentProperty(input, component.getInputs())) {
+ mappedPropertyName = input.getInputId().substring(input.getInputId().indexOf(DOT) + 1);
+ toscaInput.setDefaultp(createMappedInputPropertyDefaultValue(mappedPropertyName));
+ } else {
+ mappedPropertyName = input.getInputId();
+ toscaInput.setDefaultp(createMappedOutputDefaultValue(mappedPropertyName, interfaceType));
+ }
}
- toscaInput.setDefaultp(createDefaultValue(mappedPropertyName));
-
toscaInput.setType(input.getType());
toscaInput.setRequired(input.isRequired());
toscaInputs.put(input.getName(), toscaInput);
toscaOperation.setInputs(toscaInputs);
}
- private static Map<String, List<String>> createDefaultValue(String propertyName) {
+ private static Map<String, List<String>> createMappedInputPropertyDefaultValue(String propertyName) {
Map<String, List<String>> getPropertyMap = new HashMap<>();
List<String> values = new ArrayList<>();
values.add(SELF);
return getPropertyMap;
}
+ /**
+ * Create the value for operation input mapped to an operation output
+ * @param propertyName the mapped other operation output full name
+ * @param interfaceType full interface name
+ * @return input map for tosca
+ */
+ private static Map<String, List<String>> createMappedOutputDefaultValue(String propertyName, String interfaceType) {
+ Map<String, List<String>> getOperationOutputMap = new HashMap<>();
+ //For operation input mapped to other operation output parameter, the mapped property value
+ // should be of the format <interface name>.<operation name>.<output parameter name>
+ List<String> defaultMappedOperationOutputValue = new ArrayList<>();
+ defaultMappedOperationOutputValue.add(SELF);
+ String fullOutputPropertyName =
+ propertyName.substring(propertyName.indexOf(interfaceType) + interfaceType.length() + 1);
+ defaultMappedOperationOutputValue.add(interfaceType);
+ //Output name should not contain dot
+ defaultMappedOperationOutputValue.addAll(Arrays.asList(fullOutputPropertyName.split("\\.")));
+ getOperationOutputMap.put(GET_OPERATION_OUTPUT, defaultMappedOperationOutputValue);
+ return getOperationOutputMap;
+ }
+
private static Map<String, Object> getObjectAsMap(Object obj) {
ObjectMapper objectMapper = new ObjectMapper();
if (obj instanceof ToscaInterfaceDefinition) {
# %1 - Interface Operation input property name, component type
INTERFACE_OPERATION_INPUT_PROPERTY_NOT_FOUND_IN_COMPONENT: {
code: 404,
- message: "Error: Interface operation input parameter property '%1' not found in '%2' input properties.",
+ message: "Error: Interface operation input parameter property '%1' not found in '%2' input properties or outputs of other operations.",
messageId: "SVC4708"
}
#---------SVC4709-----------------------------
code: 400,
message: "Error: Invalid input, only pre-defined operation names are allowed in global interface type '%1'",
messageId: "SVC4713"
+ }
+#---------SVC4714-----------------------------
+# %1 - Interface Operation output name
+ INTERFACE_OPERATION_MAPPED_OUTPUT_DELETED: {
+ code: 400,
+ message: "Error: Cannot update name or delete interface operation output(s) '%1' mapped to an operation input",
+ messageId: "SVC4714"
}
\ No newline at end of file
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.when;
-import fj.data.Either;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+
+import fj.data.Either;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
private static final String RESOURCE_NAME = "Resource1";
private static final String operationId1 = "operationId1";
private static final String interfaceId1 = "interfaceId1";
+ private static final String operationName = "createOperation";
+
@InjectMocks
private InterfaceOperationBusinessLogic interfaceOperationBusinessLogic;
@Mock
public void setup() {
resource = new ResourceBuilder().setComponentType(ComponentTypeEnum.RESOURCE).setUniqueId(resourceId)
.setName(RESOURCE_NAME).build();
- resource.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinitionMap(interfaceId, operationId));
+ resource.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinitionMap(interfaceId, operationId,
+ operationName));
resource.setInputs(createInputsForResource());
user = new User();
when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
.thenReturn(Either.left(Collections.emptyMap()));
when(interfaceOperation.updateInterfaces(any(), any())).thenReturn(Either.left(
- Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId))));
+ Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId, operationName))));
Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither =
interfaceOperationBusinessLogic.createInterfaceOperation(resourceId,
- Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
- operationId)),
+ Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
+ operationId, operationName)),
user, true);
Assert.assertTrue(interfaceOperationEither.isLeft());
}
when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
.thenReturn(Either.left(Collections.emptyMap()));
when(interfaceOperation.addInterfaces(any(), any())).thenReturn(Either.left(
- Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId))));
+ Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId, operationName))));
when(interfaceOperation.updateInterfaces(any(), any())).thenReturn(Either.left(
- Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId))));
+ Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId, operationName))));
Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither =
interfaceOperationBusinessLogic.createInterfaceOperation(resourceId,
Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
- operationId)),
+ operationId, operationName)),
user, true);
Assert.assertTrue(interfaceOperationEither.isLeft());
}
Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither =
interfaceOperationBusinessLogic.createInterfaceOperation(resourceId,
Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
- operationId)),
+ operationId, operationName)),
user, true);
Assert.assertTrue(interfaceOperationEither.isRight());
}
when(interfaceOperation.updateInterfaces(any(), any()))
.thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
Assert.assertTrue(interfaceOperationBusinessLogic.createInterfaceOperation(resourceId,
- Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)),
+ Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId, operationName)),
user, true).isRight());
}
when(artifactCassandraDao.getCountOfArtifactById(any(String.class))).thenReturn(Either.left(new Long(1)));
when(artifactCassandraDao.deleteArtifact(any(String.class))).thenReturn(CassandraOperationStatus.OK);
when(interfaceOperation.updateInterfaces(any(), any())).thenReturn(Either.left(
- Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId))));
+ Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId, operationName))));
Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperation =
interfaceOperationBusinessLogic.updateInterfaceOperation(resourceId,
Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
- operationId)),
+ operationId, operationName)),
user, true);
Assert.assertTrue(interfaceOperation.isLeft());
}
Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperation =
interfaceOperationBusinessLogic.updateInterfaceOperation(resourceId,
Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
- operationId)),
+ operationId, operationName)),
user, true);
Assert.assertTrue(interfaceOperation.isRight());
}
when(artifactCassandraDao.getCountOfArtifactById(any(String.class)))
.thenReturn(Either.right(CassandraOperationStatus.NOT_FOUND));
when(interfaceOperation.updateInterfaces(any(), any())).thenReturn(Either.left(
- Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId))));
+ Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId, operationName))));
Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperation =
interfaceOperationBusinessLogic.updateInterfaceOperation(resourceId,
Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
- operationId)),
+ operationId, operationName)),
user, true);
Assert.assertTrue(interfaceOperation.isLeft());
}
Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperation =
interfaceOperationBusinessLogic.updateInterfaceOperation(resourceId,
Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
- operationId)),
+ operationId, operationName)),
user, true);
Assert.assertTrue(interfaceOperation.isRight());
}
Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither =
interfaceOperationBusinessLogic.createInterfaceOperation(resourceId,
Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
- operationId)),
+ operationId, operationName)),
user, true);
Assert.assertTrue(interfaceOperationEither.isRight());
}
Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither =
interfaceOperationBusinessLogic.createInterfaceOperation(resourceId,
Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
- operationId)),
+ operationId, operationName)),
user, true);
Assert.assertTrue(interfaceOperationEither.isRight());
}
Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither =
interfaceOperationBusinessLogic.createInterfaceOperation(resourceId,
Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
- operationId)),
+ operationId, operationName)),
user, true);
Assert.assertTrue(interfaceOperationEither.isRight());
}
@Test
public void deleteInterfaceOperationTestSuccess() {
resource.getInterfaces().get(interfaceId).getOperations()
- .putAll(InterfaceOperationTestUtils.createMockOperationMap(operationId1));
+ .putAll(InterfaceOperationTestUtils.createMockOperationMap(operationId1, operationName));
when(artifactCassandraDao.deleteArtifact(any(String.class))).thenReturn(CassandraOperationStatus.OK);
when(interfaceOperation.updateInterfaces(any(), any())).thenReturn(Either.left(Collections.emptyList()));
Assert.assertTrue(interfaceOperationBusinessLogic.deleteInterfaceOperation(resourceId, interfaceId,
Assert.assertTrue(interfaceOperationBusinessLogic.getInterfaceOperation(resourceId, interfaceId,
Collections.singletonList(operationId), user, true).isRight());
Assert.assertTrue(interfaceOperationBusinessLogic.createInterfaceOperation(resourceId,
- Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)),
+ Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId, operationName)),
user, true).isRight());
}
Assert.assertTrue(interfaceOperationBusinessLogic.getInterfaceOperation(resourceId, interfaceId,
Collections.singletonList(operationId), user, true).isRight());
Assert.assertTrue(interfaceOperationBusinessLogic.createInterfaceOperation(resourceId,
- Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)),
- user, true).isRight());
+ Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId,
+ operationName)), user, true).isRight());
}
@Test
private static final String TEST_RESOURCE_NAME = "TestResource";
private static final String operationId = "operationId";
+ private static final String operationName = "createOperation";
private static final String interfaceId = "interfaceId";
private static Resource resource;
public void setup() {
resource =
new ResourceBuilder().setComponentType(ComponentTypeEnum.RESOURCE).setName(TEST_RESOURCE_NAME).build();
- resource.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinitionMap(interfaceId, operationId));
+ resource.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinitionMap(interfaceId, operationId,
+ operationName));
}
@Test
@Test
public void testGetOperationFromInterfaceDefinitionSuccess() {
Assert.assertTrue(InterfaceOperationUtils.getOperationFromInterfaceDefinition(
- InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId), operationId).isPresent());
+ InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId, operationName), operationId).isPresent());
}
@Test
public void testGetOperationFromInterfaceDefinitionFailure() {
Assert.assertFalse(InterfaceOperationUtils.getOperationFromInterfaceDefinition(
- InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId), TEST_RESOURCE_NAME)
+ InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId, operationName), TEST_RESOURCE_NAME)
.isPresent());
}
@Test
public void testGetOperationFromInterfaceDefinitionNoOperationMap() {
InterfaceDefinition interfaceDefinition =
- InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId);
+ InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId, operationName);
interfaceDefinition.getOperations().clear();
Optional<Map.Entry<String, Operation>> operationEntry =
InterfaceOperationUtils.getOperationFromInterfaceDefinition(interfaceDefinition, TEST_RESOURCE_NAME);
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
+import static org.openecomp.sdc.test.utils.InterfaceOperationTestUtils.createMockOperation;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
public class InterfaceOperationValidationTest {
private static final String resourceId = "resourceId";
- private static final String interfaceId = "interfaceId";
private static final String operationId = "operationId";
- private static final String interfaceType = "interfaceType";
- private static final String operationType = "operationType";
private static final String operationId2 = "operationId2";
- private static final String inputId = "inputId";
- private static final String outputId = "outputId";
+ private static final String interfaceType1 = "org.test.lifecycle.standard.interfaceType.first";
+ private static final String interfaceType2 = "org.test.lifecycle.standard.interfaceType.second";
+ private static final String interfaceType3 = "org.test.lifecycle.standard.interfaceType.third";
+ private static final String operationType1 = "createOperation";
+ private static final String operationType2 = "updateOperation";
+ private static final String inputName1 = "Input1";
+ private static final String outputName1 = "Output1";
+ private static final String outputName2 = "Output2";
+
private final InterfaceOperationValidationUtilTest interfaceOperationValidationUtilTest =
new InterfaceOperationValidationUtilTest();
private final ListDataDefinition<OperationInputDefinition> operationInputDefinitionList =
new ListDataDefinition<>();
private final ListDataDefinition<OperationOutputDefinition> operationOutputDefinitionList =
new ListDataDefinition<>();
+
private Component component;
private ResponseFormatManager responseFormatManagerMock;
@Before
public void setup() {
+
MockitoAnnotations.initMocks(this);
responseFormatManagerMock = Mockito.mock(ResponseFormatManager.class);
when(responseFormatManagerMock.getResponseFormat(any())).thenReturn(new ResponseFormat());
when(responseFormatManagerMock.getResponseFormat(any(), any())).thenReturn(new ResponseFormat());
when(responseFormatManagerMock.getResponseFormat(any(), any(), any())).thenReturn(new ResponseFormat());
- component = new ResourceBuilder().setComponentType(ComponentTypeEnum.RESOURCE).setUniqueId(resourceId)
- .setName(resourceId).build();
- component.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinitionMap(interfaceId, operationId));
+ component = new ResourceBuilder()
+ .setComponentType(ComponentTypeEnum.RESOURCE)
+ .setUniqueId(resourceId)
+ .setName(resourceId)
+ .build();
+ component.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinitionMap(interfaceType1,
+ operationId, operationType1));
component.setInputs(createInputsForComponent());
}
- private List<InputDefinition> createInputsForComponent() {
- InputDefinition inputDefinition1 = new InputDefinition();
- inputDefinition1.setName(inputId);
- inputDefinition1.setInputId(inputId);
- inputDefinition1.setUniqueId(inputId);
- inputDefinition1.setValue(inputId);
- inputDefinition1.setDefaultValue(inputId);
-
- InputDefinition inputDefinition2 = new InputDefinition();
- inputDefinition2.setName(outputId);
- inputDefinition2.setInputId(outputId);
- inputDefinition2.setUniqueId(outputId);
- inputDefinition2.setValue(outputId);
- inputDefinition2.setDefaultValue(outputId);
-
- return Arrays.asList(inputDefinition1, inputDefinition2);
- }
-
@Test
public void shouldPassOperationValidationForHappyScenario() {
- operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
- operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
+ operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
+ operationOutputDefinitionList
+ .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
InterfaceDefinition interfaceDefinition =
createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
operationInputDefinitionList, operationOutputDefinitionList, "upgrade");
Assert.assertTrue(interfaceOperationValidationUtilTest
- .validateInterfaceOperations(interfaceDefinition, component,
- component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
+ .validateInterfaceOperations(interfaceDefinition, component,
+ component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false)
.isLeft());
}
- private InterfaceDefinition createInterfaceOperationData(String uniqueId, String description,
- ArtifactDefinition artifactDefinition, ListDataDefinition<OperationInputDefinition> inputs,
- ListDataDefinition<OperationOutputDefinition> outputs, String name) {
- Operation operation = new Operation();
- operation.setUniqueId(uniqueId);
- operation.setDescription(description);
- operation.setImplementation(artifactDefinition);
- operation.setInputs(inputs);
- operation.setOutputs(outputs);
- operation.setName(name);
- Map<String, Operation> operationMap = new HashMap<>();
- operationMap.put(operation.getUniqueId(), operation);
- InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
- interfaceDefinition.setOperationsMap(operationMap);
- return interfaceDefinition;
- }
-
@Test
public void shouldFailWhenOperationNameIsEmpty() {
- operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
- operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
+ operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
+ operationOutputDefinitionList
+ .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
InterfaceDefinition interfaceDefinition =
createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
operationInputDefinitionList, operationOutputDefinitionList, "");
Assert.assertTrue(interfaceOperationValidationUtilTest
- .validateInterfaceOperations(interfaceDefinition, component,
- component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
- .isRight());
+ .validateInterfaceOperations(interfaceDefinition, component,
+ component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isRight());
}
@Test
public void shouldFailWhenOperationNamesAreNotUniqueForCreate() {
- operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
- operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
- InterfaceDefinition interfaceDefinition =
- createInterfaceOperationData(operationId, operationId2, new ArtifactDefinition(),
- operationInputDefinitionList, operationOutputDefinitionList, operationId);
+ operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
+ operationOutputDefinitionList
+ .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
+ InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId, operationId2,
+ new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList, operationType1);
Assert.assertTrue(interfaceOperationValidationUtilTest
- .validateInterfaceOperations(interfaceDefinition, component,
- component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
- .isRight());
+ .validateInterfaceOperations(interfaceDefinition, component,
+ component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isRight());
}
@Test
public void shouldNotFailWhenOperationNamesAreNotUniqueForUpdate() {
- operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
- operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
+ operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
+ operationOutputDefinitionList
+ .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
InterfaceDefinition interfaceDefinition =
createInterfaceOperationData(operationId, operationId2, new ArtifactDefinition(),
operationInputDefinitionList, operationOutputDefinitionList, operationId);
Assert.assertTrue(interfaceOperationValidationUtilTest
- .validateInterfaceOperations(interfaceDefinition, component,
- component.getInterfaces().get(interfaceId), Collections.emptyMap(), true)
- .isLeft());
+ .validateInterfaceOperations(interfaceDefinition, component,
+ component.getInterfaces().get(interfaceType1), Collections.emptyMap(), true).isLeft());
}
@Test
public void shouldFailWhenOperationNameLengthIsInvalid() {
- operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
- operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
+ operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
+ operationOutputDefinitionList
+ .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
InterfaceDefinition interfaceDefinition =
createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
- operationInputDefinitionList, operationOutputDefinitionList,
+ operationInputDefinitionList,operationOutputDefinitionList,
+
"interface operation2 - The Spring Initializer provides a project generator to make you "
+ "productive with the certain technology stack from the beginning. "
- + "You can create a skeleton project"
- + "with web, data access (relational and NoSQL data stores), "
- + "cloud, or messaging support");
+ + "You can create a "
+ + "skeleton project with web, data access (relational and NoSQL data stores), "
+ + "cloud, "
+ + "or messaging support");
Assert.assertTrue(interfaceOperationValidationUtilTest
- .validateInterfaceOperations(interfaceDefinition, component,
- component.getInterfaces()
- .get(interfaceId), Collections.emptyMap(), false)
- .isRight());
+ .validateInterfaceOperations(interfaceDefinition, component,
+ component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isRight());
}
@Test
public void shouldFailWhenOperationInputParamNamesAreNotUnique() {
- operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
- operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
- operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(outputId));
- operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
+ operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
+ operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
+ operationInputDefinitionList
+ .add(InterfaceOperationTestUtils.createMockOperationInputDefinition(outputName1, 1));
+ operationOutputDefinitionList
+ .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
InterfaceDefinition interfaceDefinition =
createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
operationInputDefinitionList, operationOutputDefinitionList, "create");
Assert.assertTrue(interfaceOperationValidationUtilTest
- .validateInterfaceOperations(interfaceDefinition, component,
- component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
- .isRight());
+ .validateInterfaceOperations(interfaceDefinition, component,
+ component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isRight());
}
@Test
public void shouldPassWhenOperationInputParamNamesAreUnique() {
- operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
- operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(outputId));
- operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
+ operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
+ operationInputDefinitionList
+ .add(InterfaceOperationTestUtils.createMockOperationInputDefinition(outputName1, 1));
+ operationOutputDefinitionList
+ .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
InterfaceDefinition interfaceDefinition =
createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
operationInputDefinitionList, operationOutputDefinitionList, "update");
Assert.assertTrue(interfaceOperationValidationUtilTest
- .validateInterfaceOperations(interfaceDefinition, component,
- component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
- .isLeft());
+ .validateInterfaceOperations(interfaceDefinition, component,
+ component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isLeft());
}
@Test
public void shouldPassWhenOperationInputParamNamesHasSubProperty() {
- operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
- operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
+ operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
+ operationOutputDefinitionList
+ .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
InterfaceDefinition interfaceDefinition =
createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
operationInputDefinitionList, operationOutputDefinitionList, "update");
operationInputDefinitionList.getListToscaDataDefinition().get(0).setInputId(
operationInputDefinitionList.getListToscaDataDefinition().get(0).getInputId().concat(".subproperty"));
Assert.assertTrue(interfaceOperationValidationUtilTest
- .validateInterfaceOperations(interfaceDefinition, component,
- component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
- .isLeft());
+ .validateInterfaceOperations(interfaceDefinition, component,
+ component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isLeft());
}
@Test
public void shouldFailWhenOperationInputParamNameEmpty() {
- operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(" "));
- operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
- operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
+ operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(" ", 1));
+ operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
+ operationOutputDefinitionList
+ .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
InterfaceDefinition interfaceDefinition =
createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
operationInputDefinitionList, operationOutputDefinitionList, "update");
Assert.assertTrue(interfaceOperationValidationUtilTest
- .validateInterfaceOperations(interfaceDefinition, component,
- component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
- .isRight());
+ .validateInterfaceOperations(interfaceDefinition, component,
+ component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isRight());
}
@Test
public void shouldFailWhenOperationOutputParamNameEmpty() {
- operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
+ operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(" "));
InterfaceDefinition interfaceDefinition =
createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
operationInputDefinitionList, operationOutputDefinitionList, "update");
Assert.assertTrue(interfaceOperationValidationUtilTest
- .validateInterfaceOperations(interfaceDefinition, component,
- component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
- .isRight());
+ .validateInterfaceOperations(interfaceDefinition, component,
+ component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isRight());
}
@Test
public void shouldPassWhenInterfaceOperationOutputParamNamesUnique() {
- operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
- operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(inputId));
- operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
+ operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
+ operationOutputDefinitionList
+ .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(inputName1));
+ operationOutputDefinitionList
+ .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
InterfaceDefinition interfaceDefinition =
createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
operationInputDefinitionList, operationOutputDefinitionList, "update");
Assert.assertTrue(interfaceOperationValidationUtilTest
- .validateInterfaceOperations(interfaceDefinition, component,
- component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
- .isLeft());
+ .validateInterfaceOperations(interfaceDefinition, component,
+ component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isLeft());
}
@Test
public void shouldFailWhenOperationOutputParamNamesAreNotUnique() {
- operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
- operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(inputId));
- operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
- operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
+ operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
+ operationOutputDefinitionList
+ .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(inputName1));
+ operationOutputDefinitionList
+ .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
+ operationOutputDefinitionList
+ .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
InterfaceDefinition interfaceDefinition =
createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
operationInputDefinitionList, operationOutputDefinitionList, "update");
Assert.assertTrue(interfaceOperationValidationUtilTest
- .validateInterfaceOperations(interfaceDefinition, component,
- component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
- .isRight());
+ .validateInterfaceOperations(interfaceDefinition, component,
+ component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isRight());
}
@Test
public void shouldPassWhenOperationInputParamExistInComponentProperty() {
- operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
- operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
+ operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
+ operationOutputDefinitionList
+ .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
InterfaceDefinition interfaceDefinition =
createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
operationInputDefinitionList, operationOutputDefinitionList, "update");
Assert.assertTrue(interfaceOperationValidationUtilTest
- .validateInterfaceOperations(interfaceDefinition, component,
- component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
- .isLeft());
+ .validateInterfaceOperations(interfaceDefinition, component,
+ component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isLeft());
}
@Test
public void shouldFailWhenOperationInputParamDoesntExistInComponentProperty() {
- operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
- operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(operationId));
- operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
+ operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
+ operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 2));
+ operationOutputDefinitionList
+ .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
InterfaceDefinition interfaceDefinition =
createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
operationInputDefinitionList, operationOutputDefinitionList, "update");
Assert.assertTrue(interfaceOperationValidationUtilTest
- .validateInterfaceOperations(interfaceDefinition, component,
- component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
- .isRight());
+ .validateInterfaceOperations(interfaceDefinition, component,
+ component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isRight());
}
@Test
public void shouldFailValidateAllowedOperationCountOnLocalInterfaceType() {
InterfaceDefinition inputInterfaceDefinition =
- InterfaceOperationTestUtils.createMockInterface(interfaceId, operationType);
+ InterfaceOperationTestUtils.createMockInterface(interfaceType1
+ , operationId, operationType1);
Assert.assertTrue(interfaceOperationValidationUtilTest
- .validateInterfaceOperations(inputInterfaceDefinition, component,
- component.getInterfaces().get(interfaceId),
- InterfaceOperationTestUtils.createMockInterfaceTypeMap(interfaceType,
- operationType),
- false).isRight());
+ .validateInterfaceOperations(inputInterfaceDefinition, component,
+ component.getInterfaces().get(interfaceType1),
+ InterfaceOperationTestUtils.createMockInterfaceTypeMap(
+ interfaceType2, operationType1), false).isRight());
}
@Test
public void shouldFailValidateAllowedOperationsOnGlobalInterfaceType() {
InterfaceDefinition inputInterfaceDefinition =
- InterfaceOperationTestUtils.createMockInterface(interfaceType, operationId);
+ InterfaceOperationTestUtils.createMockInterface(interfaceType1
+ , operationId, operationType1);
Assert.assertTrue(interfaceOperationValidationUtilTest
- .validateInterfaceOperations(inputInterfaceDefinition, component,
- component.getInterfaces().get(interfaceId),
- InterfaceOperationTestUtils.createMockInterfaceTypeMap(interfaceType,
- operationType),
- false).isRight());
+ .validateInterfaceOperations(inputInterfaceDefinition, component,
+ component.getInterfaces().get(interfaceType1),
+ InterfaceOperationTestUtils.createMockInterfaceTypeMap(
+ interfaceType1, operationType1), false).isRight());
}
@Test
public void shouldPassValidateAllowedOperationsOnGlobalInterfaceType() {
InterfaceDefinition inputInterfaceDefinition =
- InterfaceOperationTestUtils.createMockInterface(interfaceType, operationType);
+ InterfaceOperationTestUtils.createMockInterface(interfaceType2,
+ operationId2, operationType2);
Assert.assertTrue(interfaceOperationValidationUtilTest
- .validateInterfaceOperations(inputInterfaceDefinition, component,
- component.getInterfaces().get(interfaceId),
- InterfaceOperationTestUtils.createMockInterfaceTypeMap(interfaceType,
- operationType),
- false).isLeft());
+ .validateInterfaceOperations(inputInterfaceDefinition, component,
+ component.getInterfaces().get(interfaceType1),
+ InterfaceOperationTestUtils.createMockInterfaceTypeMap(
+ interfaceType2, operationType2), false).isLeft());
}
@Test
public void shouldFailValidateOperationNameUniquenessInCollection() {
- InterfaceDefinition inputInterfaceDefinition =
- InterfaceOperationTestUtils.createMockInterface(interfaceType, operationType);
- inputInterfaceDefinition.getOperations()
- .put(operationId, InterfaceOperationTestUtils.createMockOperation(operationType));
+ InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType1,
+ operationId, operationType1);
+ inputInterfaceDefinition.getOperations().put(operationId,
+ createMockOperation(operationId, operationType1));
Assert.assertTrue(interfaceOperationValidationUtilTest
- .validateInterfaceOperations(inputInterfaceDefinition, component,
- component.getInterfaces().get(interfaceId),
- InterfaceOperationTestUtils.createMockInterfaceTypeMap(interfaceType,
- operationType),
- false).isRight());
+ .validateInterfaceOperations(inputInterfaceDefinition, component,
+ component.getInterfaces().get(interfaceType1),
+ InterfaceOperationTestUtils.createMockInterfaceTypeMap(
+ interfaceType1, operationType1), false).isRight());
+ }
+
+ @Test
+ public void shouldPassValidateWhenInputIsMappedToValidOutput() {
+ InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
+ operationId, operationType1);
+ inputInterfaceDefinition.getOperationsMap().values()
+ .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
+ .forEach(operationInputDefinition -> operationInputDefinition.setInputId(interfaceType1 +
+ "." + operationType1 + "." + outputName1)));
+ Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
+ component, null, Collections.emptyMap(), false).isLeft());
+ }
+
+ @Test
+ public void shouldPassValidateWhenOutputNameIsUnchanged() {
+ InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
+ operationId, operationType1);
+ InterfaceDefinition inputParamOutputMappedInterface = InterfaceOperationTestUtils.createMockInterface(
+ interfaceType2, operationId, operationType1);
+ inputParamOutputMappedInterface.getOperationsMap().values()
+ .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
+ .forEach(operationInputDefinition -> operationInputDefinition.setInputId(interfaceType2 +
+ "." + operationType2 + "." + outputName1)));
+ component.getInterfaces().put(interfaceType2, inputParamOutputMappedInterface);
+ component.getInterfaces().put(interfaceType3, InterfaceOperationTestUtils.createMockInterface(interfaceType3,
+ operationId, operationType2));
+ Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
+ component, component.getInterfaces().get(interfaceType1),
+ Collections.emptyMap(), true).isLeft());
+ }
+
+ @Test
+ public void shouldPassValidateWhenDeletedOutputIsUnMapped() {
+ InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
+ operationId, operationType1);
+ inputInterfaceDefinition.getOperationsMap().values()
+ .forEach(operation -> operation.getOutputs().getListToscaDataDefinition()
+ .forEach(operationOutputDefinition -> operationOutputDefinition.setName(outputName2)));
+ component.getInterfaces().put(interfaceType3, InterfaceOperationTestUtils.createMockInterface(
+ interfaceType3, operationId, operationType2));
+ component.getInterfaces().put(interfaceType2, InterfaceOperationTestUtils.createMockInterface(interfaceType2,
+ operationId, operationType1));
+ Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
+ component, component.getInterfaces().get(interfaceType2),
+ Collections.emptyMap(), true).isLeft());
+ }
+
+ @Test
+ public void shouldPassValidateNoOutputsInExistingInterfaceOperation() {
+ InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType1,
+ operationId, operationType1);
+ inputInterfaceDefinition.getOperationsMap().values()
+ .forEach(operation -> operation.getOutputs().getListToscaDataDefinition()
+ .forEach(operationOutputDefinition -> operationOutputDefinition.setName(outputName2)));
+ operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
+ InterfaceDefinition noOutputInterface = createInterfaceOperationData(operationId, "desc",
+ new ArtifactDefinition(), operationInputDefinitionList, null, operationType1);
+ component.getInterfaces().put(interfaceType1, noOutputInterface);
+ component.getInterfaces().put(interfaceType3, InterfaceOperationTestUtils.createMockInterface(
+ interfaceType3, operationId, operationType2));
+ Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
+ component, component.getInterfaces().get(interfaceType1),
+ Collections.emptyMap(), true).isLeft());
+ }
+
+ @Test
+ public void shouldFailValidateMappedOutputDoesNotExistInComponent() {
+ //Input parameter is mapped to invalid output (which does not exist in any of the other operations)
+ InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
+ operationId, operationType1);
+ inputInterfaceDefinition.getOperationsMap().values()
+ .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
+ .forEach(operationInputDefinition -> operationInputDefinition.setInputId(outputName2)));
+
+ Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
+ component, null, Collections.emptyMap(), false).isRight());
+ }
+
+ @Test
+ public void shouldFailValidateComponentFirstInterfaceInvalidInputMapping() {
+ //Input parameter is mapped to invalid output (which does not exist in any of the other operations)
+ InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
+ operationId, operationType1);
+ inputInterfaceDefinition.getOperationsMap().values()
+ .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
+ .forEach(operationInputDefinition -> operationInputDefinition.setInputId(outputName2)));
+ component.setInterfaces(null);
+ Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
+ component, null, Collections.emptyMap(), false).isRight());
+ }
+
+
+ @Test
+ public void shouldFailValidateMappedOutputDeletion() {
+ //Input interface from user with new output name (Output2)
+ InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
+ operationId, operationType1);
+ inputInterfaceDefinition.getOperationsMap().values()
+ .forEach(operation -> operation.getOutputs().getListToscaDataDefinition()
+ .forEach(operationOutputDefinition -> operationOutputDefinition.setName(outputName2)));
+
+ InterfaceDefinition inputParamOutputMappedInterface = InterfaceOperationTestUtils.createMockInterface(
+ interfaceType3, operationId, operationType2);
+ inputParamOutputMappedInterface.getOperationsMap().values()
+ .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
+ .forEach(operationInputDefinition -> operationInputDefinition.setInputId(interfaceType2 +
+ "." + operationType1 + "." + outputName1)));
+ component.getInterfaces().put(interfaceType3, inputParamOutputMappedInterface);
+ component.getInterfaces().put(interfaceType2, InterfaceOperationTestUtils.createMockInterface(interfaceType2,
+ operationId, operationType1));
+ Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
+ component, component.getInterfaces().get(interfaceType2),
+ Collections.emptyMap(), true).isRight());
+ }
+
+ @Test
+ public void shouldFailValidateAllMappedOutputsDeleted() {
+ //Input interface from user with all outputs deleted
+ InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
+ operationId, operationType1);
+ Map<String, Operation> operationsMap = inputInterfaceDefinition.getOperationsMap();
+ for (Map.Entry<String, Operation> operationEntry : operationsMap.entrySet()) {
+ operationEntry.getValue().setOutputs(null);
+ }
+ inputInterfaceDefinition.setOperationsMap(operationsMap);
+
+ InterfaceDefinition inputParamOutputMappedInterface = InterfaceOperationTestUtils.createMockInterface(
+ interfaceType3, operationId, operationType2);
+ inputParamOutputMappedInterface.getOperationsMap().values()
+ .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
+ .forEach(operationInputDefinition -> operationInputDefinition.setInputId(interfaceType2 +
+ "." + operationType1 + "." + outputName1)));
+ component.getInterfaces().put(interfaceType3, inputParamOutputMappedInterface);
+ component.getInterfaces().put(interfaceType2, InterfaceOperationTestUtils.createMockInterface(interfaceType2,
+ operationId, operationType1));
+ Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
+ component, component.getInterfaces().get(interfaceType2),
+ Collections.emptyMap(), true).isRight());
+ }
+
+
+ private InterfaceDefinition createInterfaceOperationData(String uniqueID, String description,
+ ArtifactDefinition artifactDefinition,
+ ListDataDefinition<OperationInputDefinition> inputs,
+ ListDataDefinition<OperationOutputDefinition> outputs,
+ String name) {
+ Operation operation = new Operation();
+ operation.setUniqueId(uniqueID);
+ operation.setDescription(description);
+ operation.setImplementation(artifactDefinition);
+ operation.setInputs(inputs);
+ operation.setOutputs(outputs);
+ operation.setName(name);
+ Map<String, Operation> operationMap = new HashMap<>();
+ operationMap.put(operation.getUniqueId(), operation);
+ InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
+ interfaceDefinition.setType(interfaceType2);
+ interfaceDefinition.setOperationsMap(operationMap);
+ return interfaceDefinition;
+ }
+
+ private List<InputDefinition> createInputsForComponent() {
+ String componentInputName = "ComponentInput1";
+ InputDefinition inputDefinition1 = new InputDefinition();
+ inputDefinition1.setName(componentInputName);
+ inputDefinition1.setInputId(componentInputName + "_inputId");
+ inputDefinition1.setUniqueId(componentInputName + "_uniqueId");
+ inputDefinition1.setValue(componentInputName + "_value");
+ inputDefinition1.setDefaultValue(componentInputName + "_defaultValue");
+
+ String componentInputName2 = "ComponentInput2";
+ InputDefinition inputDefinition2 = new InputDefinition();
+ inputDefinition2.setName(componentInputName2);
+ inputDefinition2.setInputId(componentInputName2 + "_inputId");
+ inputDefinition2.setUniqueId(componentInputName2 + "_uniqueId");
+ inputDefinition2.setValue(componentInputName2 + "_value");
+ inputDefinition2.setDefaultValue(componentInputName2 + "_defaultValue");
+
+ return Arrays.asList(inputDefinition1, inputDefinition2);
}
private class InterfaceOperationValidationUtilTest extends InterfaceOperationValidation {
package org.openecomp.sdc.be.tosca.utils;
+import static org.openecomp.sdc.be.tosca.utils.InterfacesOperationsToscaUtil.GET_OPERATION_OUTPUT;
+import static org.openecomp.sdc.be.tosca.utils.InterfacesOperationsToscaUtil.GET_PROPERTY;
+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;
+
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.ArrayList;
import java.util.HashMap;
+import java.util.List;
import java.util.Map;
+import java.util.Objects;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
+import org.openecomp.sdc.be.datatypes.elements.OperationOutputDefinition;
import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.InputDefinition;
import org.openecomp.sdc.be.model.InterfaceDefinition;
import org.openecomp.sdc.be.model.Resource;
import org.openecomp.sdc.be.model.Service;
import org.openecomp.sdc.be.tosca.ToscaExportHandler;
import org.openecomp.sdc.be.tosca.ToscaRepresentation;
-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.model.ToscaTemplate;
import org.openecomp.sdc.common.util.YamlToObjectConverter;
private static final String MAPPED_PROPERTY_NAME = "mapped_property";
private static final String INPUT_NAME_PREFIX = "input_";
+ private static final String OUTPUT_NAME_PREFIX = "output_";
private static final String NODE_TYPE_NAME = "test";
private String[] inputTypes = {"string", "integer", "float", "boolean"};
private static ObjectMapper mapper;
component.setNormalizedName("normalizedComponentName");
InterfaceDefinition addedInterface = new InterfaceDefinition();
addedInterface.setType("interface.types.test_resource_name");
- addOperationsToInterface(addedInterface, 5, 3, true);
+ addOperationsToInterface(component, addedInterface, 5, 3, true, false);
final String interfaceType = "normalizedComponentName-interface";
component.setInterfaces(new HashMap<>());
component.getInterfaces().put(interfaceType, addedInterface);
final Map<String, Object> interfaceTypeElement =
- InterfacesOperationsToscaUtil.addInterfaceTypeElement(component, new ArrayList<>());
+ addInterfaceTypeElement(component, new ArrayList<>());
ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null);
ToscaTemplate template = new ToscaTemplate("test");
component.setNormalizedName("normalizedServiceComponentName");
InterfaceDefinition addedInterface = new InterfaceDefinition();
addedInterface.setType("interface.types.test_service_name");
- addOperationsToInterface(addedInterface, 5, 3, true);
+ addOperationsToInterface(component, addedInterface, 5, 3, true, false);
final String interfaceType = "normalizedServiceComponentName-interface";
component.setInterfaces(new HashMap<>());
component.getInterfaces().put(interfaceType, addedInterface);
final Map<String, Object> interfaceTypeElement =
- InterfacesOperationsToscaUtil.addInterfaceTypeElement(component, new ArrayList<>());
+ addInterfaceTypeElement(component, new ArrayList<>());
ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null);
ToscaTemplate template = new ToscaTemplate("testService");
InterfaceDefinition addedInterface = new InterfaceDefinition();
addedInterface.setType("com.some.resource.or.other.resourceName");
- addOperationsToInterface(addedInterface, 3, 2, true);
+ addOperationsToInterface(component, addedInterface, 3, 2, true, false);
final String interfaceType = "normalizedComponentName-interface";
component.setInterfaces(new HashMap<>());
component.getInterfaces().put(interfaceType, addedInterface);
ToscaNodeType nodeType = new ToscaNodeType();
- InterfacesOperationsToscaUtil.addInterfaceDefinitionElement(component, nodeType, false);
+ addInterfaceDefinitionElement(component, nodeType, false);
ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null);
ToscaTemplate template = new ToscaTemplate(NODE_TYPE_NAME);
Assert.assertFalse(mainYaml.contains("operations"));
Assert.assertTrue(mainYaml.contains("resourceName:"));
Assert.assertTrue(mainYaml.contains("inputs:"));
- validateOperationInputs(mainYaml);
+ validateOperationInputs(mainYaml, 2, null);
Assert.assertFalse(mainYaml.contains("defaultp"));
Assert.assertTrue(mainYaml.contains("has description"));
Assert.assertTrue(mainYaml.contains(MAPPED_PROPERTY_NAME));
component.setNormalizedName("normalizedServiceComponentName");
InterfaceDefinition addedInterface = new InterfaceDefinition();
addedInterface.setType("com.some.service.or.other.serviceName");
- addOperationsToInterface(addedInterface, 3, 2, true);
+ addOperationsToInterface(component, addedInterface, 3, 2, true, false);
final String interfaceType = "normalizedServiceComponentName-interface";
component.setInterfaces(new HashMap<>());
component.getInterfaces().put(interfaceType, addedInterface);
ToscaNodeType nodeType = new ToscaNodeType();
- InterfacesOperationsToscaUtil.addInterfaceDefinitionElement(component, nodeType, false);
+ addInterfaceDefinitionElement(component, nodeType, false);
ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null);
ToscaTemplate template = new ToscaTemplate("testService");
Assert.assertFalse(mainYaml.contains("operations"));
Assert.assertTrue(mainYaml.contains("serviceName:"));
Assert.assertTrue(mainYaml.contains("inputs:"));
- validateOperationInputs(mainYaml);
+ validateOperationInputs(mainYaml, 2, null);
Assert.assertFalse(mainYaml.contains("defaultp"));
Assert.assertTrue(mainYaml.contains("has description"));
Assert.assertTrue(mainYaml.contains(MAPPED_PROPERTY_NAME));
component.setNormalizedName("normalizedComponentName");
InterfaceDefinition addedInterface = new InterfaceDefinition();
addedInterface.setType("com.some.resource.or.other.resourceNameNoInputs");
- addOperationsToInterface(addedInterface, 3, 3, false);
+ addOperationsToInterface(component, addedInterface, 3, 3, false, false);
final String interfaceType = "normalizedComponentName-interface";
component.setInterfaces(new HashMap<>());
component.getInterfaces().put(interfaceType, addedInterface);
ToscaNodeType nodeType = new ToscaNodeType();
- InterfacesOperationsToscaUtil.addInterfaceDefinitionElement(component, nodeType, false);
+ addInterfaceDefinitionElement(component, nodeType, false);
ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null);
ToscaTemplate template = new ToscaTemplate("test");
Assert.assertTrue(toscaRepresentation.getMainYaml().contains("com.some.resource.or.other.resourceName"));
}
+ @Test
+ public void addInterfaceDefinitionElementInputMappedToOtherOperationOutput() {
+ String addedInterfaceType = "com.some.resource.or.other.resourceNameInputMappedToOutput";
+ Component component = new Resource();
+ component.setNormalizedName("normalizedComponentName");
+ InterfaceDefinition addedInterface = new InterfaceDefinition();
+ addedInterface.setType(addedInterfaceType);
+ addOperationsToInterface(component, addedInterface, 2, 2, true, true);
+ addedInterface.getOperationsMap().values().stream()
+ .filter(operationInputDefinition -> operationInputDefinition.getName().equalsIgnoreCase(
+ "name_for_op_0"))
+ .forEach(operation -> operation.getInputs().getListToscaDataDefinition().stream()
+ .filter(operationInputDefinition -> operationInputDefinition.getName().contains("integer"))
+ .forEach(operationInputDefinition -> operationInputDefinition.setInputId(addedInterfaceType +
+ ".name_for_op_1.output_integer_1")));
+ component.setInterfaces(new HashMap<>());
+ component.getInterfaces().put(addedInterfaceType, addedInterface);
+ ToscaNodeType nodeType = new ToscaNodeType();
+ addInterfaceDefinitionElement(component, nodeType, false);
+
+ ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null);
+ ToscaTemplate template = new ToscaTemplate("test");
+ Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
+ nodeTypes.put("test", nodeType);
+ template.setNode_types(nodeTypes);
+ final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template);
+
+ String mainYaml = toscaRepresentation.getMainYaml();
+ Assert.assertFalse(mainYaml.contains("operations"));
+ Assert.assertTrue(mainYaml.contains("resourceNameInputMappedToOutput:"));
+ Assert.assertTrue(mainYaml.contains("inputs:"));
+ validateOperationInputs(mainYaml, 2, "name_for_op_1");
+ }
- private void addOperationsToInterface(InterfaceDefinition addedInterface, int numOfOps, int numOfInputsPerOp,
- boolean hasInputs) {
+ private void addOperationsToInterface(Component component, InterfaceDefinition addedInterface, int numOfOps,
+ int numOfInputsPerOp, boolean hasInputs, boolean hasOutputs) {
addedInterface.setOperations(new HashMap<>());
for (int i = 0; i < numOfOps; i++) {
implementation.setArtifactName(i + "_createBPMN.bpmn");
operation.setImplementation(implementation);
if (hasInputs) {
- operation.setInputs(createInputs(numOfInputsPerOp));
+ operation.setInputs(createInputs(component, numOfInputsPerOp));
+ }
+ if (hasOutputs) {
+ operation.setOutputs(createOutputs(numOfInputsPerOp));
}
addedInterface.getOperations().put(operation.getName(), operation);
}
}
- private ListDataDefinition<OperationInputDefinition> createInputs(int numOfInputs) {
+ private ListDataDefinition<OperationInputDefinition> createInputs(Component component, int numOfInputs) {
ListDataDefinition<OperationInputDefinition> operationInputDefinitionList = new ListDataDefinition<>();
for (int i = 0; i < numOfInputs; i++) {
+ String mappedPropertyName = java.util.UUID.randomUUID().toString() + "." + MAPPED_PROPERTY_NAME + i;
operationInputDefinitionList.add(createMockOperationInputDefinition(
- INPUT_NAME_PREFIX + inputTypes[i] + "_" + i,
- java.util.UUID.randomUUID().toString() + "." + MAPPED_PROPERTY_NAME, i));
+ INPUT_NAME_PREFIX + inputTypes[i] + "_" + i, mappedPropertyName, i));
+ addMappedPropertyAsComponentInput(component, mappedPropertyName);
+
}
return operationInputDefinitionList;
}
+ private void addMappedPropertyAsComponentInput(Component component, String mappedPropertyName) {
+ InputDefinition componentInput = new InputDefinition();
+ componentInput.setUniqueId(mappedPropertyName.split("\\.")[0]);
+ componentInput.setName(mappedPropertyName.split("\\.")[1]);
+ if (Objects.isNull(component.getInputs())) {
+ component.setInputs(new ArrayList<>());
+ }
+ component.getInputs().add(componentInput);
+ }
+
+ private ListDataDefinition<OperationOutputDefinition> createOutputs(int numOfOutputs) {
+ ListDataDefinition<OperationOutputDefinition> operationOutputDefinitionList = new ListDataDefinition<>();
+ for (int i = 0; i < numOfOutputs; i++) {
+ operationOutputDefinitionList.add(createMockOperationOutputDefinition(
+ OUTPUT_NAME_PREFIX + inputTypes[i] + "_" + i, i));
+ }
+ return operationOutputDefinitionList;
+ }
private OperationInputDefinition createMockOperationInputDefinition(String name, String id, int index) {
OperationInputDefinition operationInputDefinition = new OperationInputDefinition();
return operationInputDefinition;
}
- private void validateOperationInputs(String mainYaml) {
+ private OperationOutputDefinition createMockOperationOutputDefinition(String name, int index) {
+ OperationOutputDefinition operationInputDefinition = new OperationOutputDefinition();
+ operationInputDefinition.setName(name);
+ operationInputDefinition.setType(inputTypes[index]);
+ operationInputDefinition.setRequired(index % 2 == 0);
+ return operationInputDefinition;
+ }
+
+ private void validateOperationInputs(String mainYaml, int numOfInputsPerOp, String mappedOperationName) {
String nodeTypeKey = NODE_TYPE_NAME + ":";
String nodeTypesRepresentation = mainYaml.substring(mainYaml.indexOf(nodeTypeKey) + nodeTypeKey.length(),
- mainYaml.lastIndexOf(MAPPED_PROPERTY_NAME) + MAPPED_PROPERTY_NAME.length());
+ mainYaml.lastIndexOf(MAPPED_PROPERTY_NAME) + MAPPED_PROPERTY_NAME.length()
+ + String.valueOf(numOfInputsPerOp).length());
YamlToObjectConverter objectConverter = new YamlToObjectConverter();
ToscaNodeType toscaNodeType = objectConverter.convert(nodeTypesRepresentation.getBytes(), ToscaNodeType.class);
Map<String, Object> interfaces = toscaNodeType.getInterfaces();
- for (Object interfaceVal : interfaces.values()) {
- Map<String, Object> interfaceDefinition = mapper.convertValue(interfaceVal, Map.class);
- for (Object operationVal : interfaceDefinition.values()) {
+ for (Map.Entry<String, Object> interfaceEntry : interfaces.entrySet()) {
+ Map<String, Object> interfaceDefinition = mapper.convertValue(interfaceEntry.getValue(), Map.class);
+ for (Map.Entry<String, Object> operationEntry : interfaceDefinition.entrySet()) {
+ Object operationVal = operationEntry.getValue();
if (operationVal instanceof Map) {
- validateOperationInputDefinition(operationVal);
+ validateOperationInputDefinition((String) interfaceDefinition.get("type"), mappedOperationName,
+ operationVal);
}
}
}
}
- private void validateOperationInputDefinition(Object operationVal) {
- ToscaLifecycleOperationDefinition operation =
- mapper.convertValue(operationVal, ToscaLifecycleOperationDefinition.class);
- Map<String, ToscaProperty> inputs = operation.getInputs();
- for (Map.Entry<String, ToscaProperty> inputEntry : inputs.entrySet()) {
- Assert.assertEquals(inputEntry.getKey().split("_")[1], inputEntry.getValue().getType());
- Boolean expectedIsRequired = Integer.parseInt(inputEntry.getKey().split("_")[2]) % 2 == 0;
- Assert.assertEquals(expectedIsRequired, inputEntry.getValue().getRequired());
+ private void validateOperationInputDefinition(String interfaceType, String operationName, Object operationVal) {
+ Map<String, Object> operation = mapper.convertValue(operationVal, Map.class);
+ Map<String, Object> inputs = (Map<String, Object>) operation.get("inputs");
+ for (Map.Entry<String, Object> inputEntry : inputs.entrySet()) {
+ String[] inputNameSplit = inputEntry.getKey().split("_");
+ Map<String, Object> inputValueObject = (Map<String, Object>) inputEntry.getValue();
+ Assert.assertEquals(inputNameSplit[1], inputValueObject.get("type"));
+ Boolean expectedIsRequired = Integer.parseInt(inputNameSplit[2]) % 2 == 0;
+ Assert.assertEquals(expectedIsRequired, inputValueObject.get("required"));
+ validateOperationInputDefinitionDefaultValue(interfaceType, operationName, inputNameSplit[1],
+ Integer.parseInt(inputNameSplit[2]), inputValueObject);
+ }
+ }
+
+
+ private void validateOperationInputDefinitionDefaultValue(String interfaceType, String operationName,
+ String inputType, int index,
+ Map<String, Object> inputValueObject) {
+ Map<String, Object> mappedInputValue = (Map<String, Object>) inputValueObject.get("default");
+ if(mappedInputValue.containsKey(GET_PROPERTY)) {
+ String mappedPropertyValue = MAPPED_PROPERTY_NAME + index;
+ List<String> mappedPropertyDefaultValue = (List<String>) mappedInputValue.get(GET_PROPERTY);
+ Assert.assertEquals(2, mappedPropertyDefaultValue.size());
+ Assert.assertTrue(mappedPropertyDefaultValue.contains(SELF));
+ Assert.assertTrue(mappedPropertyDefaultValue.contains(mappedPropertyValue));
+ } else if(mappedInputValue.containsKey(GET_OPERATION_OUTPUT)) {
+ List<String> mappedPropertyDefaultValue = (List<String>) mappedInputValue.get(GET_OPERATION_OUTPUT);
+ Assert.assertEquals(4, mappedPropertyDefaultValue.size());
+ String mappedPropertyValue = OUTPUT_NAME_PREFIX + inputType + "_" + index;
+ Assert.assertTrue(mappedPropertyDefaultValue.contains(SELF));
+ Assert.assertTrue(mappedPropertyDefaultValue.contains(interfaceType));
+ Assert.assertTrue(mappedPropertyDefaultValue.contains(operationName));
+ Assert.assertTrue(mappedPropertyDefaultValue.contains(mappedPropertyValue));
+ } else {
+ Assert.fail("Invalid Tosca function in default value. Allowed values: "+ GET_PROPERTY +
+ "/"+ GET_OPERATION_OUTPUT);
}
}
}
import java.util.HashMap;
import java.util.Map;
+
import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
import org.openecomp.sdc.be.datatypes.elements.OperationOutputDefinition;
public class InterfaceOperationTestUtils {
- public static Map<String, InterfaceDefinition> createMockInterfaceDefinitionMap(String interfaceId,
- String operationId) {
- Map<String, InterfaceDefinition> interfaceDefinitionMap = new HashMap<>();
- interfaceDefinitionMap.put(interfaceId, createMockInterface(interfaceId, operationId));
- return interfaceDefinitionMap;
- }
-
- public static InterfaceDefinition createMockInterface(String interfaceId, String operationId) {
- return createInterface(interfaceId, interfaceId, interfaceId, interfaceId, createMockOperationMap(operationId));
- }
-
private static InterfaceDefinition createInterface(String uniqueId, String description, String type,
String toscaResourceName, Map<String, Operation> op) {
InterfaceDefinition id = new InterfaceDefinition();
return id;
}
- public static Map<String, Operation> createMockOperationMap(String operationId) {
+ public static Map<String, InterfaceDefinition> createMockInterfaceDefinitionMap(String interfaceId,
+ String operationId,
+ String operationName) {
+ Map<String, InterfaceDefinition> interfaceDefinitionMap = new HashMap<>();
+ interfaceDefinitionMap.put(interfaceId, createMockInterface(interfaceId, operationId, operationName));
+ return interfaceDefinitionMap;
+ }
+
+ public static InterfaceDefinition createMockInterface(String interfaceId, String operationId, String operationName) {
+ return createInterface(interfaceId, interfaceId, interfaceId, interfaceId, createMockOperationMap(operationId,
+ operationName));
+ }
+
+ public static Map<String, Operation> createMockOperationMap(String operationId, String operationName) {
Map<String, Operation> operationMap = new HashMap<>();
- operationMap.put(operationId, createMockOperation(operationId));
+ operationMap.put(operationId, createMockOperation(operationId, operationName));
return operationMap;
}
- public static Operation createMockOperation(String operationId) {
+ public static Operation createMockOperation(String operationId, String operationName) {
Operation operation = new Operation();
ListDataDefinition<OperationInputDefinition> operationInputDefinitionList = new ListDataDefinition<>();
- operationInputDefinitionList.add(createMockOperationInputDefinition("inputId"));
+ operationInputDefinitionList.add(createMockOperationInputDefinition("Input1", 1));
operation.setInputs(operationInputDefinitionList);
ListDataDefinition<OperationOutputDefinition> operationOutputDefList = new ListDataDefinition<>();
- operationOutputDefList.add(createMockOperationOutputDefinition("outputId"));
+ operationOutputDefList.add(createMockOperationOutputDefinition("Output1"));
operation.setOutputs(operationOutputDefList);
operation.setDefinition(false);
- operation.setName(operationId);
+ operation.setName(operationName);
operation.setUniqueId(operationId);
ArtifactDefinition implementation = new ArtifactDefinition();
implementation.setUniqueId("uniqId");
return operation;
}
- public static OperationInputDefinition createMockOperationInputDefinition(String inputId) {
+ public static OperationInputDefinition createMockOperationInputDefinition(String inputName, int num) {
OperationInputDefinition operationInputDefinition = new OperationInputDefinition();
- operationInputDefinition.setName(inputId);
- operationInputDefinition.setUniqueId(inputId);
- operationInputDefinition.setInputId(inputId);
- operationInputDefinition.setValue(inputId);
- operationInputDefinition.setDefaultValue(inputId);
+ operationInputDefinition.setName(inputName);
+ operationInputDefinition.setUniqueId(inputName + "_uniqueId");
+ operationInputDefinition.setInputId("ComponentInput" + num + "_uniqueId");
+ operationInputDefinition.setValue(inputName + "_value");
+ operationInputDefinition.setDefaultValue(inputName + "_defaultValue");
return operationInputDefinition;
}
- public static OperationOutputDefinition createMockOperationOutputDefinition(String outputId) {
+ public static OperationOutputDefinition createMockOperationOutputDefinition(String outputName) {
OperationOutputDefinition operationOutputDefinition = new OperationOutputDefinition();
- operationOutputDefinition.setName(outputId);
- operationOutputDefinition.setUniqueId(outputId);
- operationOutputDefinition.setInputId(outputId);
- operationOutputDefinition.setValue(outputId);
- operationOutputDefinition.setDefaultValue(outputId);
+ operationOutputDefinition.setName(outputName);
+ operationOutputDefinition.setUniqueId(outputName + "_uniqueId");
+ operationOutputDefinition.setValue(outputName + "_value");
+ operationOutputDefinition.setDefaultValue(outputName + "_defaultValue");
return operationOutputDefinition;
}
INTERFACE_OPERATION_NOT_FOUND, INTERFACE_OPERATION_NAME_ALREADY_IN_USE, INTERFACE_OPERATION_NAME_MANDATORY,
INTERFACE_OPERATION_NAME_INVALID, INTERFACE_OPERATION_INPUT_NAME_ALREADY_IN_USE,
INTERFACE_OPERATION_OUTPUT_NAME_ALREADY_IN_USE, INTERFACE_OPERATION_NOT_DELETED,
+ INTERFACE_OPERATION_MAPPED_OUTPUT_DELETED,
INTERFACE_OPERATION_INPUT_NAME_MANDATORY, INTERFACE_OPERATION_OUTPUT_NAME_MANDATORY,
INTERFACE_OPERATION_INPUT_PROPERTY_NOT_FOUND_IN_COMPONENT, INTERFACE_OPERATION_INVALID_FOR_LOCAL_TYPE,
INTERFACE_OPERATION_INVALID_FOR_GLOBAL_TYPE,
Code Review / sdc.git / commitdiff