Operation Outputs - Operation screen BE

1. Added implementation for using operation
outputs as mapping to input from create/update
operation screen
2. Handled populating the mapped outputs to
Tosca
3. Unit tests

Change-Id: I3d4761b07be0d4e363ff84710e92438e694a3b07
Issue-ID: SDC-2085
Signed-off-by: ojasdubey <ojas.dubey@amdocs.com>

9 files changed, 864 insertions, 342 deletions

diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/utils/InterfaceOperationUtils.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/utils/InterfaceOperationUtils.java
index 0233711a89..6615e9ef37 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/utils/InterfaceOperationUtils.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/utils/InterfaceOperationUtils.java
@@ -16,10 +16,15 @@
 
 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;
 
@@ -61,4 +66,16 @@ public class InterfaceOperationUtils {
                        .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('.'))))) ;
+    }
+
+
 }
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/validation/InterfaceOperationValidation.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/validation/InterfaceOperationValidation.java
index c80f57486d..d17762fc90 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/validation/InterfaceOperationValidation.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/validation/InterfaceOperationValidation.java
@@ -16,7 +16,11 @@
 
 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;
@@ -26,13 +30,17 @@ import java.util.Objects;
 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;
@@ -47,9 +55,10 @@ public class InterfaceOperationValidation {
 
     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,
@@ -71,8 +80,8 @@ public class InterfaceOperationValidation {
         }
 
         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;
             }
@@ -87,15 +96,13 @@ public class InterfaceOperationValidation {
 
         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);
@@ -105,22 +112,17 @@ public class InterfaceOperationValidation {
             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);
@@ -140,16 +142,19 @@ public class InterfaceOperationValidation {
     }
 
     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()) {
@@ -157,14 +162,15 @@ public class InterfaceOperationValidation {
             }
 
             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()) {
@@ -172,15 +178,81 @@ public class InterfaceOperationValidation {
             }
         }
 
+        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());
@@ -194,8 +266,8 @@ public class InterfaceOperationValidation {
             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());
         }
@@ -209,7 +281,7 @@ public class InterfaceOperationValidation {
     }
 
     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 =
@@ -222,38 +294,16 @@ public class InterfaceOperationValidation {
         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 =
@@ -266,9 +316,9 @@ public class InterfaceOperationValidation {
         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);
@@ -330,31 +380,22 @@ public class InterfaceOperationValidation {
                 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));
@@ -363,17 +404,170 @@ public class InterfaceOperationValidation {
     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);
     }
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsToscaUtil.java b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsToscaUtil.java
index fbef11d2e8..efed3e9f15 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsToscaUtil.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsToscaUtil.java
@@ -16,6 +16,8 @@
 
 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;
 
@@ -47,10 +49,12 @@ public class InterfacesOperationsToscaUtil {
     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() {
     }
 
@@ -127,7 +131,7 @@ public class 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);
             }
@@ -176,7 +180,9 @@ public class InterfacesOperationsToscaUtil {
     }
 
     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;
@@ -186,12 +192,16 @@ public class InterfacesOperationsToscaUtil {
         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);
@@ -200,7 +210,7 @@ public class InterfacesOperationsToscaUtil {
         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);
@@ -213,6 +223,27 @@ public class InterfacesOperationsToscaUtil {
         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) {
diff --git a/catalog-be/src/main/resources/config/error-configuration.yaml b/catalog-be/src/main/resources/config/error-configuration.yaml
index ff86aff820..315027b43e 100644
--- a/catalog-be/src/main/resources/config/error-configuration.yaml
+++ b/catalog-be/src/main/resources/config/error-configuration.yaml
@@ -2137,7 +2137,7 @@ errors:
 # %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-----------------------------
@@ -2172,4 +2172,11 @@ errors:
         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
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogicTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogicTest.java
index 8509f3e749..df4ef646ee 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogicTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogicTest.java
@@ -24,12 +24,13 @@ import static org.mockito.ArgumentMatchers.anyString;
 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;
@@ -70,6 +71,8 @@ public class InterfaceOperationBusinessLogicTest {
     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
@@ -97,7 +100,8 @@ public class InterfaceOperationBusinessLogicTest {
     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();
@@ -126,11 +130,11 @@ public class InterfaceOperationBusinessLogicTest {
         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());
     }
@@ -141,13 +145,13 @@ public class InterfaceOperationBusinessLogicTest {
         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());
     }
@@ -162,7 +166,7 @@ public class InterfaceOperationBusinessLogicTest {
         Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither =
                 interfaceOperationBusinessLogic.createInterfaceOperation(resourceId,
                         Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
-                                operationId)),
+                                operationId, operationName)),
                         user, true);
         Assert.assertTrue(interfaceOperationEither.isRight());
     }
@@ -174,7 +178,7 @@ public class InterfaceOperationBusinessLogicTest {
         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());
     }
 
@@ -185,11 +189,11 @@ public class InterfaceOperationBusinessLogicTest {
         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());
     }
@@ -203,7 +207,7 @@ public class InterfaceOperationBusinessLogicTest {
         Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperation =
                 interfaceOperationBusinessLogic.updateInterfaceOperation(resourceId,
                         Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
-                                operationId)),
+                                operationId, operationName)),
                         user, true);
         Assert.assertTrue(interfaceOperation.isRight());
     }
@@ -215,11 +219,11 @@ public class InterfaceOperationBusinessLogicTest {
         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());
     }
@@ -231,7 +235,7 @@ public class InterfaceOperationBusinessLogicTest {
         Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperation =
                 interfaceOperationBusinessLogic.updateInterfaceOperation(resourceId,
                         Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
-                                operationId)),
+                                operationId, operationName)),
                         user, true);
         Assert.assertTrue(interfaceOperation.isRight());
     }
@@ -244,7 +248,7 @@ public class InterfaceOperationBusinessLogicTest {
         Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither =
                 interfaceOperationBusinessLogic.createInterfaceOperation(resourceId,
                         Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
-                                operationId)),
+                                operationId, operationName)),
                         user, true);
         Assert.assertTrue(interfaceOperationEither.isRight());
     }
@@ -256,7 +260,7 @@ public class InterfaceOperationBusinessLogicTest {
         Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither =
                 interfaceOperationBusinessLogic.createInterfaceOperation(resourceId,
                         Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
-                                operationId)),
+                                operationId, operationName)),
                         user, true);
         Assert.assertTrue(interfaceOperationEither.isRight());
     }
@@ -271,7 +275,7 @@ public class InterfaceOperationBusinessLogicTest {
         Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither =
                 interfaceOperationBusinessLogic.createInterfaceOperation(resourceId,
                         Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
-                                operationId)),
+                                operationId, operationName)),
                         user, true);
         Assert.assertTrue(interfaceOperationEither.isRight());
     }
@@ -291,7 +295,7 @@ public class InterfaceOperationBusinessLogicTest {
     @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,
@@ -374,7 +378,7 @@ public class InterfaceOperationBusinessLogicTest {
         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());
     }
 
@@ -387,8 +391,8 @@ public class InterfaceOperationBusinessLogicTest {
         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
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/utils/InterfaceOperationUtilsTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/utils/InterfaceOperationUtilsTest.java
index 59f95ba8da..8ceac17d46 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/utils/InterfaceOperationUtilsTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/utils/InterfaceOperationUtilsTest.java
@@ -15,6 +15,7 @@ public class InterfaceOperationUtilsTest {
 
     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;
 
@@ -22,7 +23,8 @@ public class InterfaceOperationUtilsTest {
     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
@@ -72,20 +74,20 @@ public class InterfaceOperationUtilsTest {
     @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);
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/validation/InterfaceOperationValidationTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/validation/InterfaceOperationValidationTest.java
index fc1b03ed78..e2d83aef29 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/validation/InterfaceOperationValidationTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/validation/InterfaceOperationValidationTest.java
@@ -18,12 +18,14 @@ package org.openecomp.sdc.be.components.validation;
 
 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;
@@ -46,317 +48,476 @@ import org.openecomp.sdc.test.utils.InterfaceOperationTestUtils;
 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 {
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsToscaUtilTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsToscaUtilTest.java
index 983ef91a8c..36dd5d9796 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsToscaUtilTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsToscaUtilTest.java
@@ -16,12 +16,20 @@
 
 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;
@@ -31,15 +39,15 @@ import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
 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;
 
@@ -47,6 +55,7 @@ public class InterfacesOperationsToscaUtilTest {
 
     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;
@@ -65,12 +74,12 @@ public class InterfacesOperationsToscaUtilTest {
         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");
@@ -87,12 +96,12 @@ public class InterfacesOperationsToscaUtilTest {
         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");
@@ -110,12 +119,12 @@ public class InterfacesOperationsToscaUtilTest {
         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);
@@ -128,7 +137,7 @@ public class InterfacesOperationsToscaUtilTest {
         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));
@@ -141,12 +150,12 @@ public class InterfacesOperationsToscaUtilTest {
         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");
@@ -158,7 +167,7 @@ public class InterfacesOperationsToscaUtilTest {
         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));
@@ -171,12 +180,12 @@ public class InterfacesOperationsToscaUtilTest {
         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");
@@ -193,9 +202,42 @@ public class InterfacesOperationsToscaUtilTest {
         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++) {
@@ -206,23 +248,46 @@ public class InterfacesOperationsToscaUtilTest {
             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();
@@ -233,31 +298,70 @@ public class InterfacesOperationsToscaUtilTest {
         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);
         }
     }
 }
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/test/utils/InterfaceOperationTestUtils.java b/catalog-be/src/test/java/org/openecomp/sdc/test/utils/InterfaceOperationTestUtils.java
index f21d5a9dcf..c614c6e6e9 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/test/utils/InterfaceOperationTestUtils.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/test/utils/InterfaceOperationTestUtils.java
@@ -18,6 +18,7 @@ package org.openecomp.sdc.test.utils;
 
 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;
@@ -27,17 +28,6 @@ import org.openecomp.sdc.be.model.Operation;
 
 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();
@@ -49,24 +39,37 @@ public class InterfaceOperationTestUtils {
         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");
@@ -77,23 +80,22 @@ public class InterfaceOperationTestUtils {
         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;
     }