Interface operation feature enhancements

1. API restructuring to enhance model and provide more capabilities.
2. Allowed multiple interface creation under same resource/service.
3. Enhanced validations to align with updated model.
4. API restructuring to align UI model with Tosca model.
5. Enhanced Junit and code coverage.
6. Added BDD and CI-API tests.

Change-Id: I2d8ac8a6154fd9be8254836ba0da1540210031c0
Issue-ID: SDC-1999
Signed-off-by: priyanshu <pagarwal@amdocs.com>

23 files changed, 1649 insertions, 1438 deletions

diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ArtifactsBusinessLogic.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ArtifactsBusinessLogic.java
index 2b3ee0ed2e..8f1f5864d5 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ArtifactsBusinessLogic.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ArtifactsBusinessLogic.java
@@ -56,7 +56,7 @@ import org.openecomp.sdc.be.model.*;
 import org.openecomp.sdc.be.model.heat.HeatParameterType;
 import org.openecomp.sdc.be.model.jsontitan.operations.InterfaceOperation;
 import org.openecomp.sdc.be.model.jsontitan.operations.NodeTemplateOperation;
-import org.openecomp.sdc.be.model.jsontitan.utils.InterfaceUtils;
+import org.openecomp.sdc.be.components.utils.InterfaceOperationUtils;
 import org.openecomp.sdc.be.model.operations.api.*;
 import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
@@ -179,9 +179,6 @@ public class ArtifactsBusinessLogic extends BaseBusinessLogic {
     @Autowired
     private ArtifactsResolver artifactsResolver;
 
-    @Autowired
-    private InterfaceOperation interfaceOperation;
-
     public enum ArtifactOperationEnum {
         CREATE, UPDATE, DELETE, DOWNLOAD, LINK;
 
@@ -3058,7 +3055,7 @@ public class ArtifactsBusinessLogic extends BaseBusinessLogic {
             }
         } else {
             return updateArtifactsFlowForInterfaceOperations(parent, parentId, artifactId, artifactInfo, user,
-                    decodedPayload, componentType, auditingAction, operationUuid, artifactData, prevArtifactId,
+                    decodedPayload, componentType, auditingAction, interfaceType, operationUuid, artifactData, prevArtifactId,
                     currArtifactId, artifactDefinition);
         }
 
@@ -3067,7 +3064,7 @@ public class ArtifactsBusinessLogic extends BaseBusinessLogic {
 
     private Either<Either<ArtifactDefinition, Operation>, ResponseFormat> updateArtifactsFlowForInterfaceOperations(
             Component parent, String parentId, String artifactId, ArtifactDefinition artifactInfo, User user,
-            byte[] decodedPayload, ComponentTypeEnum componentType, AuditingActionEnum auditingAction,
+            byte[] decodedPayload, ComponentTypeEnum componentType, AuditingActionEnum auditingAction, String interfaceType,
             String operationUuid, ESArtifactData artifactData, String prevArtifactId, String currArtifactId,
             ArtifactDefinition artifactDefinition) {
         StorageOperationStatus error;
@@ -3110,24 +3107,15 @@ public class ArtifactsBusinessLogic extends BaseBusinessLogic {
         }
         Component storedComponent = componentStorageOperationStatusEither.left().value();
 
-        String interfaceToscaName = InterfaceUtils.createInterfaceToscaResourceName(
-                storedComponent.getName());
-        //fetch the interface from storage
-        Optional<InterfaceDefinition> interfaceDefinition =
-                storedComponent.getInterfaces().values().stream()
-                        .filter(interfaceDef -> interfaceDef.getToscaResourceName()
-                        .equals(interfaceToscaName)).findFirst();
-        if (!interfaceDefinition.isPresent()) {
+        Optional<InterfaceDefinition> optionalInterface = InterfaceOperationUtils
+            .getInterfaceDefinitionFromComponentByInterfaceType(storedComponent, interfaceType);
+        if(!optionalInterface.isPresent()) {
             log.debug("Failed to get resource interface for resource Id {}", parentId);
-            ResponseFormat responseFormat = componentsUtils.getResponseFormat(
-                    ActionStatus.INTERFACE_OPERATION_NOT_FOUND, parentId);
-            handleAuditing(auditingAction, parent, parentId, user, artifactInfo, prevArtifactId,
-                    currArtifactId, responseFormat, componentType, null);
-            return Either.right(responseFormat);
+            return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_NOT_FOUND_IN_COMPONENT, interfaceType));
         }
 
         //fetch the operation from storage
-        InterfaceDefinition gotInterface = interfaceDefinition.get();
+        InterfaceDefinition gotInterface = optionalInterface.get();
         Map<String, Operation> operationsMap = gotInterface.getOperationsMap();
         Optional<Operation> optionalOperation = operationsMap.values()
                 .stream()
@@ -3152,8 +3140,8 @@ public class ArtifactsBusinessLogic extends BaseBusinessLogic {
         implementationArtifact.setEsId(artifactInfo.getEsId());
         operation.setImplementation(implementationArtifact);
         gotInterface.setOperationsMap(operationsMap);
-        Either<InterfaceDefinition, StorageOperationStatus> interfaceDefinitionStorageOperationStatusEither =
-                interfaceOperation.updateInterface(storedComponent.getUniqueId(), gotInterface);
+        Either<List<InterfaceDefinition>, StorageOperationStatus> interfaceDefinitionStorageOperationStatusEither =
+                interfaceOperation.updateInterfaces(storedComponent.getUniqueId(), Collections.singletonList(gotInterface));
         if (interfaceDefinitionStorageOperationStatusEither.isRight()){
             StorageOperationStatus storageOperationStatus = interfaceDefinitionStorageOperationStatusEither.right().value();
             ActionStatus actionStatus =
@@ -5027,13 +5015,13 @@ public class ArtifactsBusinessLogic extends BaseBusinessLogic {
      * @param componentType
      * @param componentUuid
      * @param artifactUUID
-     * @param operation        TODO
+     * @param operation
      * @return
      */
     public Either<ArtifactDefinition, ResponseFormat> updateArtifactOnInterfaceOperationByResourceUUID(
             String data, HttpServletRequest request, ComponentTypeEnum componentType,
-            String componentUuid, String artifactUUID, String operationUUID,
-            ResourceCommonInfo resourceCommonInfo,ArtifactOperationInfo operation) {
+            String componentUuid, String interfaceUUID, String operationUUID, String artifactUUID,
+        ResourceCommonInfo resourceCommonInfo,ArtifactOperationInfo operation) {
         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
         Either<ArtifactDefinition, ResponseFormat> updateArtifactResult;
         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> actionResult = null;
@@ -5067,7 +5055,7 @@ public class ArtifactsBusinessLogic extends BaseBusinessLogic {
             resourceCommonInfo.setResourceName(componentName);
         }
         if (errorWrapper.isEmpty()) {
-            Either<String, ResponseFormat> interfaceName = fetchInterfaceName(componentId);
+            Either<String, ResponseFormat> interfaceName = fetchInterfaceName(componentId, interfaceUUID);
             if (interfaceName.isRight()) {
                 errorWrapper.setInnerElement(interfaceName.right().value());
             }
@@ -5094,19 +5082,21 @@ public class ArtifactsBusinessLogic extends BaseBusinessLogic {
         return updateArtifactResult;
     }
 
-    private Either<String, ResponseFormat> fetchInterfaceName(String componentId) {
-        Either<Component, StorageOperationStatus> componentStorageOperationStatusEither =
-                toscaOperationFacade.getToscaElement(componentId);
+    private Either<String, ResponseFormat> fetchInterfaceName(String componentId, String interfaceUUID) {
+        Either<Component, StorageOperationStatus> componentStorageOperationStatusEither = toscaOperationFacade.getToscaElement(componentId);
         if (componentStorageOperationStatusEither.isRight()) {
             StorageOperationStatus errorStatus = componentStorageOperationStatusEither.right().value();
             log.debug("Failed to fetch component information by component id, error {}", errorStatus);
-            return Either.right(componentsUtils
-                    .getResponseFormat(componentsUtils.convertFromStorageResponse(errorStatus)));
+            return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(errorStatus)));
         }
         Component storedComponent = componentStorageOperationStatusEither.left().value();
 
-        return Either.left(InterfaceUtils.createInterfaceToscaResourceName(
-                storedComponent.getName()));
+        Optional<InterfaceDefinition> optionalInterface = InterfaceOperationUtils
+            .getInterfaceDefinitionFromComponentByInterfaceId(storedComponent, interfaceUUID);
+        if(!optionalInterface.isPresent()) {
+            return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_NOT_FOUND_IN_COMPONENT, interfaceUUID));
+        }
+        return Either.left(optionalInterface.get().getType());
     }
 
 
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/BaseBusinessLogic.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/BaseBusinessLogic.java
index 02e64334f9..8ee1864862 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/BaseBusinessLogic.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/BaseBusinessLogic.java
@@ -128,10 +128,7 @@ public abstract class BaseBusinessLogic {
     protected InterfaceOperation interfaceOperation;
 
     @Autowired
-    protected InterfaceOperationBusinessLogic interfaceOperationBusinessLogic;
-
-    @Autowired
-    protected InterfaceLifecycleOperation interfaceLifecycleOperation;
+    protected InterfaceLifecycleOperation interfaceLifecycleTypeOperation;
 
     @javax.annotation.Resource
     private UserValidations userValidations;
@@ -167,18 +164,6 @@ public abstract class BaseBusinessLogic {
         this.propertyOperation = propertyOperation;
     }
 
-    public void setInterfaceOperation(InterfaceOperation interfaceOperation) {
-        this.interfaceOperation = interfaceOperation;
-    }
-    public void setInterfaceOperationBusinessLogic(InterfaceOperationBusinessLogic interfaceOperationBusinessLogic) {
-        this.interfaceOperationBusinessLogic = interfaceOperationBusinessLogic;
-    }
-
-
-    public void setInterfaceLifecycleOperation(InterfaceLifecycleOperation interfaceLifecycleOperation) {
-        this.interfaceLifecycleOperation = interfaceLifecycleOperation;
-    }
-
     User validateUserNotEmpty(User user, String ecompErrorContext) {
         return userValidations.validateUserNotEmpty(user, ecompErrorContext);
     }
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogic.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogic.java
index a0efddbdda..2fb7b0f09e 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogic.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogic.java
@@ -18,15 +18,28 @@
 package org.openecomp.sdc.be.components.impl;
 
 import fj.data.Either;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.stream.Collectors;
+import org.openecomp.sdc.be.components.utils.InterfaceOperationUtils;
 import org.openecomp.sdc.be.components.validation.InterfaceOperationValidation;
 import org.openecomp.sdc.be.dao.api.ActionStatus;
-import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
+import org.openecomp.sdc.be.dao.cassandra.ArtifactCassandraDao;
+import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus;
+import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
 import org.openecomp.sdc.be.model.ArtifactDefinition;
 import org.openecomp.sdc.be.model.InterfaceDefinition;
 import org.openecomp.sdc.be.model.Operation;
 import org.openecomp.sdc.be.model.User;
-import org.openecomp.sdc.be.model.jsontitan.utils.InterfaceUtils;
 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
@@ -36,305 +49,375 @@ import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Map;
-import java.util.Optional;
-import java.util.UUID;
-import java.util.stream.Collectors;
-
 @Component("interfaceOperationBusinessLogic")
 public class InterfaceOperationBusinessLogic extends BaseBusinessLogic {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(InterfaceOperationBusinessLogic.class);
-    private static final String FAILED_TO_LOCK_COMPONENT_RESPONSE_IS = "Failed to lock component {}. Response is {}";
-    private static final String EXCEPTION_OCCURRED_DURING_INTERFACE_OPERATION = "Exception occurred during {}. Response is {}";
+    private static final String EXCEPTION_OCCURRED_DURING_INTERFACE_OPERATION =
+            "Exception occurred during {}. Response is {}";
     private static final String DELETE_INTERFACE_OPERATION = "deleteInterfaceOperation";
     private static final String GET_INTERFACE_OPERATION = "getInterfaceOperation";
     private static final String CREATE_INTERFACE_OPERATION = "createInterfaceOperation";
     private static final String UPDATE_INTERFACE_OPERATION = "updateInterfaceOperation";
 
     @Autowired
+    private ArtifactCassandraDao artifactCassandraDao;
+
+    @Autowired
     private InterfaceOperationValidation interfaceOperationValidation;
 
-    public void setInterfaceOperationValidation(InterfaceOperationValidation interfaceOperationValidation) {
-        this.interfaceOperationValidation = interfaceOperationValidation;
-    }
+    public Either<List<InterfaceDefinition>, ResponseFormat> deleteInterfaceOperation(String componentId,
+            String interfaceId, List<String> operationsToDelete, User user, boolean lock) {
+        validateUserExists(user.getUserId(), DELETE_INTERFACE_OPERATION, true);
 
-    public Either<Operation, ResponseFormat> deleteInterfaceOperation(String componentId, String interfaceOperationToDelete, User user, boolean lock) {
         Either<org.openecomp.sdc.be.model.Component, ResponseFormat> componentEither = getComponentDetails(componentId);
-        if (componentEither.isRight()){
+        if (componentEither.isRight()) {
             return Either.right(componentEither.right().value());
         }
         org.openecomp.sdc.be.model.Component storedComponent = componentEither.left().value();
-        validateUserExists(user.getUserId(), DELETE_INTERFACE_OPERATION, true);
 
-        Either<Boolean, ResponseFormat> lockResult = lockComponentResult(lock, storedComponent, DELETE_INTERFACE_OPERATION);
+        Either<Boolean, ResponseFormat> lockResult =
+                lockComponentResult(lock, storedComponent, DELETE_INTERFACE_OPERATION);
         if (lockResult.isRight()) {
             return Either.right(lockResult.right().value());
         }
 
         try {
-            Optional<InterfaceDefinition> optionalInterface = InterfaceUtils.getInterfaceDefinitionFromToscaName(storedComponent.getInterfaces().values(), storedComponent.getName());
-            Either<InterfaceDefinition, ResponseFormat> getInterfaceEither = getInterfaceDefinition(storedComponent, optionalInterface.orElse(null));
-            if (getInterfaceEither.isRight()) {
-                return Either.right(getInterfaceEither.right().value());
+            Optional<InterfaceDefinition> optionalInterface = InterfaceOperationUtils
+                                                                      .getInterfaceDefinitionFromComponentByInterfaceId(
+                                                                              storedComponent, interfaceId);
+            if (!optionalInterface.isPresent()) {
+                return Either.right(
+                        componentsUtils.getResponseFormat(ActionStatus.INTERFACE_NOT_FOUND_IN_COMPONENT, interfaceId));
+            }
+            InterfaceDefinition interfaceDefinition = optionalInterface.get();
+
+            Map<String, Operation> operationsCollection = new HashMap<>();
+            for (String operationId : operationsToDelete) {
+                Optional<Map.Entry<String, Operation>> optionalOperation =
+                        InterfaceOperationUtils.getOperationFromInterfaceDefinition(interfaceDefinition, operationId);
+                if (!optionalOperation.isPresent()) {
+                    return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_OPERATION_NOT_FOUND,
+                            storedComponent.getUniqueId()));
+                }
+
+                Operation storedOperation = optionalOperation.get().getValue();
+                String artifactUuId = storedOperation.getImplementation().getArtifactUUID();
+                CassandraOperationStatus cassandraStatus = artifactCassandraDao.deleteArtifact(artifactUuId);
+                if (cassandraStatus != CassandraOperationStatus.OK) {
+                    ResponseFormat responseFormatByArtifactId = componentsUtils.getResponseFormatByArtifactId(
+                            componentsUtils.convertFromStorageResponse(
+                                    componentsUtils.convertToStorageOperationStatus(cassandraStatus)),
+                            storedOperation.getImplementation().getArtifactDisplayName());
+                    return Either.right(responseFormatByArtifactId);
+                }
+
+                operationsCollection.put(operationId, interfaceDefinition.getOperationsMap().get(operationId));
+                interfaceDefinition.getOperations().remove(operationId);
             }
-            InterfaceDefinition interfaceDefinition = getInterfaceEither.left().value();
 
-            Either<Operation, ResponseFormat> getOperationEither = getOperationFromInterfaceDef(storedComponent, interfaceDefinition, interfaceOperationToDelete);
-            if (getOperationEither.isRight()){
-                return Either.right(getOperationEither.right().value());
+            Either<List<InterfaceDefinition>, StorageOperationStatus> deleteOperationEither =
+                    interfaceOperation.updateInterfaces(storedComponent.getUniqueId(),
+                            Collections.singletonList(interfaceDefinition));
+            if (deleteOperationEither.isRight()) {
+                titanDao.rollback();
+                return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(
+                        deleteOperationEither.right().value(), storedComponent.getComponentType())));
             }
 
-            Either<Operation, StorageOperationStatus> deleteEither = interfaceOperation.deleteInterfaceOperation(componentId, interfaceDefinition, interfaceOperationToDelete);
-            if (deleteEither.isRight()){
-                LOGGER.error("Failed to delete interface operation from component {}. Response is {}", storedComponent.getName(), deleteEither.right().value());
-                return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(deleteEither.right().value(), storedComponent.getComponentType())));
+            if (interfaceDefinition.getOperations().isEmpty()) {
+                Either<String, StorageOperationStatus> deleteInterfaceEither = interfaceOperation.deleteInterface(
+                        storedComponent.getUniqueId(), interfaceDefinition.getUniqueId());
+                if (deleteInterfaceEither.isRight()) {
+                    titanDao.rollback();
+                    return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(
+                            deleteInterfaceEither.right().value(), storedComponent.getComponentType())));
+                }
             }
 
             titanDao.commit();
-            return Either.left(deleteEither.left().value());
-        }
-        catch (Exception e){
+            interfaceDefinition.getOperations().putAll(operationsCollection);
+            interfaceDefinition.getOperations().keySet().removeIf(key -> !(operationsToDelete.contains(key)));
+            return Either.left(Collections.singletonList(interfaceDefinition));
+        } catch (Exception e) {
             LOGGER.error(EXCEPTION_OCCURRED_DURING_INTERFACE_OPERATION, "delete", e);
             titanDao.rollback();
             return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_OPERATION_NOT_DELETED));
-        }
-        finally {
+        } finally {
             if (lockResult.isLeft() && lockResult.left().value()) {
-                graphLockOperation.unlockComponent(storedComponent.getUniqueId(), NodeTypeEnum.getByNameIgnoreCase(storedComponent.getComponentType().getValue()));
+                graphLockOperation.unlockComponent(storedComponent.getUniqueId(),
+                        NodeTypeEnum.getByNameIgnoreCase(storedComponent.getComponentType().getValue()));
             }
         }
     }
 
-    public Either<Operation, ResponseFormat> getInterfaceOperation(String componentId, String interfaceOperationToGet, User user, boolean lock) {
+    private Either<org.openecomp.sdc.be.model.Component, ResponseFormat> getComponentDetails(String componentId) {
+        Either<org.openecomp.sdc.be.model.Component, StorageOperationStatus> componentStorageOperationStatusEither =
+                toscaOperationFacade.getToscaElement(componentId);
+        if (componentStorageOperationStatusEither.isRight()) {
+            return Either.right(componentsUtils.getResponseFormat(
+                    componentsUtils.convertFromStorageResponse(componentStorageOperationStatusEither.right().value())));
+        }
+        return Either.left(componentStorageOperationStatusEither.left().value());
+    }
+
+    private Either<Boolean, ResponseFormat> lockComponentResult(boolean lock,
+            org.openecomp.sdc.be.model.Component component, String action) {
+        if (lock) {
+            Either<Boolean, ResponseFormat> lockResult = lockComponent(component.getUniqueId(), component, action);
+            if (lockResult.isRight()) {
+                titanDao.rollback();
+                return Either.right(lockResult.right().value());
+            }
+        }
+        return Either.left(true);
+    }
+
+    public Either<List<InterfaceDefinition>, ResponseFormat> getInterfaceOperation(String componentId,
+            String interfaceId, List<String> operationsToGet, User user, boolean lock) {
+        validateUserExists(user.getUserId(), GET_INTERFACE_OPERATION, true);
+
         Either<org.openecomp.sdc.be.model.Component, ResponseFormat> componentEither = getComponentDetails(componentId);
-        if (componentEither.isRight()){
+        if (componentEither.isRight()) {
             return Either.right(componentEither.right().value());
         }
         org.openecomp.sdc.be.model.Component storedComponent = componentEither.left().value();
-        validateUserExists(user.getUserId(), GET_INTERFACE_OPERATION, true);
 
-        Either<Boolean, ResponseFormat> lockResult = lockComponentResult(lock, storedComponent, GET_INTERFACE_OPERATION);
+        Either<Boolean, ResponseFormat> lockResult =
+                lockComponentResult(lock, storedComponent, GET_INTERFACE_OPERATION);
         if (lockResult.isRight()) {
             return Either.right(lockResult.right().value());
         }
 
         try {
-            Optional<InterfaceDefinition> optionalInterface = InterfaceUtils.getInterfaceDefinitionFromToscaName(storedComponent.getInterfaces().values(), storedComponent.getName());
-            Either<InterfaceDefinition, ResponseFormat> getInterfaceEither = getInterfaceDefinition(storedComponent, optionalInterface.orElse(null));
-            if (getInterfaceEither.isRight()) {
-                return Either.right(getInterfaceEither.right().value());
+            Optional<InterfaceDefinition> optionalInterface = InterfaceOperationUtils
+                                                                      .getInterfaceDefinitionFromComponentByInterfaceId(
+                                                                              storedComponent, interfaceId);
+            if (!optionalInterface.isPresent()) {
+                return Either.right(
+                        componentsUtils.getResponseFormat(ActionStatus.INTERFACE_NOT_FOUND_IN_COMPONENT, interfaceId));
             }
-            InterfaceDefinition interfaceDefinition = getInterfaceEither.left().value();
-
-            Either<Operation, ResponseFormat> getOperationEither = getOperationFromInterfaceDef(storedComponent, interfaceDefinition, interfaceOperationToGet);
-            if (getOperationEither.isRight()){
-                return Either.right(getOperationEither.right().value());
+            InterfaceDefinition interfaceDefinition = optionalInterface.get();
+
+            for (String operationId : operationsToGet) {
+                Optional<Map.Entry<String, Operation>> optionalOperation =
+                        InterfaceOperationUtils.getOperationFromInterfaceDefinition(interfaceDefinition, operationId);
+                if (!optionalOperation.isPresent()) {
+                    return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_OPERATION_NOT_FOUND,
+                            storedComponent.getUniqueId()));
+                }
             }
 
             titanDao.commit();
-            return Either.left(getOperationEither.left().value());
-        }
-        catch (Exception e){
+            interfaceDefinition.getOperations().keySet().removeIf(key -> !(operationsToGet.contains(key)));
+            return Either.left(Collections.singletonList(interfaceDefinition));
+        } catch (Exception e) {
             LOGGER.error(EXCEPTION_OCCURRED_DURING_INTERFACE_OPERATION, "get", e);
             titanDao.rollback();
-            return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_OPERATION_NOT_FOUND, componentId));
-        }
-        finally {
+            return Either.right(
+                    componentsUtils.getResponseFormat(ActionStatus.INTERFACE_OPERATION_NOT_FOUND, componentId));
+        } finally {
             if (lockResult.isLeft() && lockResult.left().value()) {
-                graphLockOperation.unlockComponent(storedComponent.getUniqueId(), NodeTypeEnum.getByNameIgnoreCase(storedComponent.getComponentType().getValue()));
+                graphLockOperation.unlockComponent(storedComponent.getUniqueId(),
+                        NodeTypeEnum.getByNameIgnoreCase(storedComponent.getComponentType().getValue()));
             }
         }
     }
 
-    private Either<InterfaceDefinition, ResponseFormat> getInterfaceDefinition(org.openecomp.sdc.be.model.Component component, InterfaceDefinition interfaceDef) {
-        if (interfaceDef != null){
-            return Either.left(interfaceDef);
-        } else {
-            InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
-            interfaceDefinition.setToscaResourceName(InterfaceUtils.createInterfaceToscaResourceName(component.getName()));
-            Either<InterfaceDefinition, StorageOperationStatus> interfaceCreateEither = interfaceOperation.addInterface(component.getUniqueId(), interfaceDefinition);
-            if (interfaceCreateEither.isRight()){
-                StorageOperationStatus sValue = interfaceCreateEither.right().value();
-                LOGGER.error("Failed to get interface from component {}. Response is {}", component.getName(), sValue);
-                return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(sValue, component.getComponentType()), ""));
-            }
-            return Either.left(interfaceCreateEither.left().value());
-        }
+    public Either<List<InterfaceDefinition>, ResponseFormat> createInterfaceOperation(String componentId,
+            List<InterfaceDefinition> interfaceDefinitions, User user, boolean lock) {
+        return createOrUpdateInterfaceOperation(componentId, interfaceDefinitions, user, false,
+                CREATE_INTERFACE_OPERATION, lock);
     }
 
-    public Either<Operation, ResponseFormat> createInterfaceOperation(String componentId, Operation operation, User user, boolean lock) {
-        return createOrUpdateInterfaceOperation(componentId, operation, user, false, CREATE_INTERFACE_OPERATION, lock);
-    }
-
-    public Either<Operation, ResponseFormat> updateInterfaceOperation(String componentId, Operation operation, User user, boolean lock) {
-        return createOrUpdateInterfaceOperation(componentId, operation, user, true, UPDATE_INTERFACE_OPERATION, lock);
-    }
+    private Either<List<InterfaceDefinition>, ResponseFormat> createOrUpdateInterfaceOperation(String componentId,
+            List<InterfaceDefinition> interfaceDefinitions, User user, boolean isUpdate, String errorContext,
+            boolean lock) {
+        validateUserExists(user.getUserId(), errorContext, true);
 
-    private Either<Operation, ResponseFormat> createOrUpdateInterfaceOperation(String componentId, Operation operation, User user, boolean isUpdate, String errorContext, boolean lock) {
         Either<org.openecomp.sdc.be.model.Component, ResponseFormat> componentEither = getComponentDetails(componentId);
-        if (componentEither.isRight()){
+        if (componentEither.isRight()) {
             return Either.right(componentEither.right().value());
         }
         org.openecomp.sdc.be.model.Component storedComponent = componentEither.left().value();
-        validateUserExists(user.getUserId(), errorContext, true);
-        Either<Boolean, ResponseFormat> interfaceOperationValidationResponseEither = interfaceOperationValidation
-            .validateInterfaceOperations(Collections.singletonList(operation), storedComponent, isUpdate);
-        if(interfaceOperationValidationResponseEither.isRight()) {
-            return 	Either.right(interfaceOperationValidationResponseEither.right().value());
-        }
 
         Either<Boolean, ResponseFormat> lockResult = lockComponentResult(lock, storedComponent, errorContext);
         if (lockResult.isRight()) {
             return Either.right(lockResult.right().value());
         }
 
+        Either<Map<String, InterfaceDefinition>, ResponseFormat> interfaceLifecycleTypes =
+                getAllInterfaceLifecycleTypes();
+        if (interfaceLifecycleTypes.isRight()) {
+            return Either.right(interfaceLifecycleTypes.right().value());
+        }
+
         try {
-            Optional<InterfaceDefinition> optionalInterface = InterfaceUtils.getInterfaceDefinitionFromToscaName(storedComponent.getInterfaces().values(), storedComponent.getName());
-            Either<InterfaceDefinition, ResponseFormat> getInterfaceEither = getInterfaceDefinition(storedComponent, optionalInterface.orElse(null));
-            if (getInterfaceEither.isRight()) {
-                return Either.right(getInterfaceEither.right().value());
-            }
-            InterfaceDefinition interfaceDefinition = getInterfaceEither.left().value();
+            List<InterfaceDefinition> interfacesCollection = new ArrayList<>();
+            Map<String, Operation> operationsCollection = new HashMap<>();
+            for (InterfaceDefinition inputInterfaceDefinition : interfaceDefinitions) {
+                Optional<InterfaceDefinition> optionalInterface =
+                        InterfaceOperationUtils.getInterfaceDefinitionFromComponentByInterfaceType(
+                                storedComponent, inputInterfaceDefinition.getType());
+                Either<Boolean, ResponseFormat> interfaceOperationValidationResponseEither =
+                        interfaceOperationValidation
+                                .validateInterfaceOperations(inputInterfaceDefinition, storedComponent,
+                                        optionalInterface.orElse(null), interfaceLifecycleTypes.left().value(),
+                                        isUpdate);
+                if (interfaceOperationValidationResponseEither.isRight()) {
+                    return Either.right(interfaceOperationValidationResponseEither.right().value());
+                }
 
-            Either<Operation, StorageOperationStatus> result;
-            if(!isUpdate){
-                initNewOperation(operation);
-                result = interfaceOperation.addInterfaceOperation(componentId, interfaceDefinition, operation);
-            }
-            else {
-                Either<Operation, ResponseFormat> getOperationEither = getOperationFromInterfaceDef(storedComponent, interfaceDefinition, operation.getUniqueId());
-                if (getOperationEither.isRight()){
-                    return Either.right(getOperationEither.right().value());
+                Map<String, Operation> operationsToAddOrUpdate = inputInterfaceDefinition.getOperationsMap();
+                operationsCollection.putAll(operationsToAddOrUpdate);
+                inputInterfaceDefinition.getOperations().clear();
+
+                Either<InterfaceDefinition, ResponseFormat> getInterfaceEither =
+                        getOrCreateInterfaceDefinition(storedComponent, inputInterfaceDefinition,
+                                optionalInterface.orElse(null));
+                if (getInterfaceEither.isRight()) {
+                    return Either.right(getInterfaceEither.right().value());
                 }
-                updateExistingOperation(operation, getOperationEither.left().value().getImplementation().getArtifactUUID());
-                result = interfaceOperation.updateInterfaceOperation(componentId, interfaceDefinition, operation);
+                InterfaceDefinition interfaceDef = getInterfaceEither.left().value();
+
+                updateOperationInputDefs(storedComponent, operationsToAddOrUpdate.values());
+
+                for (Operation operation : operationsToAddOrUpdate.values()) {
+                    if (!isUpdate) {
+                        addOperationToInterface(interfaceDef, operation);
+                    } else {
+                        Optional<Map.Entry<String, Operation>> optionalOperation =
+                                InterfaceOperationUtils.getOperationFromInterfaceDefinition(interfaceDef,
+                                        operation.getUniqueId());
+                        if (!optionalOperation.isPresent()) {
+                            titanDao.rollback();
+                            return Either.right(componentsUtils
+                                                        .getResponseFormat(ActionStatus.INTERFACE_OPERATION_NOT_FOUND,
+                                                                storedComponent.getUniqueId()));
+                        }
+
+                        Operation storedOperation = optionalOperation.get().getValue();
+                        String artifactUuId = storedOperation.getImplementation().getArtifactUUID();
+                        Either<Long, CassandraOperationStatus> artifactCount =
+                                artifactCassandraDao.getCountOfArtifactById(artifactUuId);
+                        if (artifactCount.isLeft()) {
+                            CassandraOperationStatus cassandraStatus =
+                                    artifactCassandraDao.deleteArtifact(artifactUuId);
+                            if (cassandraStatus != CassandraOperationStatus.OK) {
+                                titanDao.rollback();
+                                ResponseFormat responseFormatByArtifactId =
+                                        componentsUtils.getResponseFormatByArtifactId(
+                                                componentsUtils.convertFromStorageResponse(
+                                                        componentsUtils.convertToStorageOperationStatus(
+                                                                cassandraStatus)),
+                                                storedOperation.getImplementation().getArtifactDisplayName());
+                                return Either.right(responseFormatByArtifactId);
+                            }
+                        }
+                        updateOperationOnInterface(interfaceDef, operation, artifactUuId);
+                    }
+                }
+                interfacesCollection.add(interfaceDef);
             }
 
-            if (result.isRight()) {
+            Either<List<InterfaceDefinition>, StorageOperationStatus> addCreateOperationEither =
+                    interfaceOperation.updateInterfaces(storedComponent.getUniqueId(), interfacesCollection);
+            if (addCreateOperationEither.isRight()) {
                 titanDao.rollback();
-                LOGGER.debug("Failed to addOrUpdate interface operation on component {}. Response is {}", storedComponent.getName(), result.right().value());
-                return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(result.right().value(), storedComponent.getComponentType())));
+                return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(
+                        addCreateOperationEither.right().value(), storedComponent.getComponentType())));
             }
 
             titanDao.commit();
-            return Either.left(result.left().value());
-        }
-        catch (Exception e) {
+            interfacesCollection.forEach(interfaceDefinition -> interfaceDefinition.getOperations().entrySet().removeIf(
+                    entry -> !operationsCollection.values().stream().map(OperationDataDefinition::getName)
+                                      .collect(Collectors.toList()).contains(entry.getValue().getName())));
+            return Either.left(interfacesCollection);
+        } catch (Exception e) {
             titanDao.rollback();
             LOGGER.error(EXCEPTION_OCCURRED_DURING_INTERFACE_OPERATION, "addOrUpdate", e);
             return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
-        }
-        finally {
+        } finally {
             if (lockResult.isLeft() && lockResult.left().value()) {
-                graphLockOperation.unlockComponent(storedComponent.getUniqueId(), NodeTypeEnum.getByNameIgnoreCase(storedComponent.getComponentType().getValue()));
+                graphLockOperation.unlockComponent(storedComponent.getUniqueId(),
+                        NodeTypeEnum.getByNameIgnoreCase(storedComponent.getComponentType().getValue()));
             }
         }
     }
 
-    private Either<org.openecomp.sdc.be.model.Component, ResponseFormat> getComponentDetails(String componentId){
-        Either<org.openecomp.sdc.be.model.Component, StorageOperationStatus> componentStorageOperationStatusEither = toscaOperationFacade.getToscaElement(componentId);
-        if (componentStorageOperationStatusEither.isRight()) {
-            StorageOperationStatus errorStatus = componentStorageOperationStatusEither.right().value();
-            LOGGER.error("Failed to fetch component information by component id {}, Response is {}", componentId, errorStatus);
-            return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(errorStatus)));
-        }
-        return Either.left(componentStorageOperationStatusEither.left().value());
-    }
+    public Either<Map<String, InterfaceDefinition>, ResponseFormat> getAllInterfaceLifecycleTypes() {
 
-    private Either<Operation, ResponseFormat> getOperationFromInterfaceDef(
-        org.openecomp.sdc.be.model.Component component, InterfaceDefinition interfaceDefinition, String operationToFetch) {
-        Optional<Map.Entry<String, Operation>> operationMap = interfaceDefinition.getOperationsMap().entrySet().stream()
-            .filter(entry -> entry.getValue().getUniqueId().equals(operationToFetch)).findAny();
-        if (!operationMap.isPresent()) {
-            LOGGER.error("Failed to get interface operation from component {}. Response is {}", component.getUniqueId(), ActionStatus.INTERFACE_OPERATION_NOT_FOUND);
-            return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_OPERATION_NOT_FOUND, component.getUniqueId()));
+        Either<Map<String, InterfaceDefinition>, StorageOperationStatus> interfaceLifecycleTypes =
+                interfaceLifecycleTypeOperation.getAllInterfaceLifecycleTypes();
+        if (interfaceLifecycleTypes.isRight()) {
+            return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_LIFECYCLE_TYPES_NOT_FOUND));
         }
-        return Either.left(operationMap.get().getValue());
-    }
-
-    private void initNewOperation(Operation operation){
-        ArtifactDefinition artifactDefinition = new ArtifactDefinition();
-        String artifactUUID = UUID.randomUUID().toString();
-        artifactDefinition.setArtifactUUID(artifactUUID);
-        artifactDefinition.setUniqueId(artifactUUID);
-        artifactDefinition.setArtifactType(ArtifactTypeEnum.WORKFLOW.getType());
-        artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
-        operation.setUniqueId(UUID.randomUUID().toString());
-        operation.setImplementation(artifactDefinition);
-    }
+        interfaceLifecycleTypes.left().value().values().forEach(id -> id.setOperations(
+                id.getOperations().keySet().stream().collect(Collectors.toMap(key -> key.replaceFirst(
+                        id.getUniqueId() + ".", ""), i -> id.getOperations().get(i)))));
 
-    private void updateExistingOperation(Operation operation, String artifactUUID){
-        ArtifactDefinition artifactDefinition = new ArtifactDefinition();
-        artifactDefinition.setArtifactUUID(artifactUUID);
-        artifactDefinition.setUniqueId(artifactUUID);
-        artifactDefinition.setArtifactType(ArtifactTypeEnum.WORKFLOW.getType());
-        artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
-        operation.setImplementation(artifactDefinition);
+        return Either.left(interfaceLifecycleTypes.left().value());
     }
 
-    private Either<Boolean, ResponseFormat> lockComponentResult(boolean lock, org.openecomp.sdc.be.model.Component component, String action){
-        if (lock) {
-            Either<Boolean, ResponseFormat> lockResult = lockComponent(component.getUniqueId(), component, action);
-            if (lockResult.isRight()) {
-                LOGGER.debug(FAILED_TO_LOCK_COMPONENT_RESPONSE_IS, component.getName(), lockResult.right().value().getFormattedMessage());
+    private Either<InterfaceDefinition, ResponseFormat> getOrCreateInterfaceDefinition(
+            org.openecomp.sdc.be.model.Component component, InterfaceDefinition interfaceDefinition,
+            InterfaceDefinition storedInterfaceDef) {
+        if (storedInterfaceDef != null) {
+            return Either.left(storedInterfaceDef);
+        } else {
+            interfaceDefinition.setUniqueId(UUID.randomUUID().toString());
+            interfaceDefinition.setToscaResourceName(interfaceDefinition.getType());
+            Either<List<InterfaceDefinition>, StorageOperationStatus> interfaceCreateEither =
+                    interfaceOperation.addInterfaces(component.getUniqueId(),
+                            Collections.singletonList(interfaceDefinition));
+            if (interfaceCreateEither.isRight()) {
                 titanDao.rollback();
-                return Either.right(lockResult.right().value());
+                return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(
+                        interfaceCreateEither.right().value(), component.getComponentType())));
             }
+            return Either.left(interfaceCreateEither.left().value().get(0));
         }
-        return Either.left(true);
     }
 
-    public Either<Boolean, ResponseFormat> validateComponentNameAndUpdateInterfaces(org.openecomp.sdc.be.model.Component oldComponent,
-                                                                                    org.openecomp.sdc.be.model.Component newComponent) {
-        if(!oldComponent.getName().equals(newComponent.getName()) ) {
-            Collection<InterfaceDefinition> interfaceDefinitionListFromToscaName = InterfaceUtils
-                    .getInterfaceDefinitionListFromToscaName(oldComponent.getInterfaces().values(),
-                            oldComponent.getName());
-            for (InterfaceDefinition interfaceDefinition : interfaceDefinitionListFromToscaName) {
-
-                Either<InterfaceDefinition, ResponseFormat> interfaceDefinitionResponseEither = updateInterfaceDefinition(oldComponent,
-                                                                    newComponent, interfaceDefinition);
-                if(interfaceDefinitionResponseEither.isRight()) {
-                    return Either.right(interfaceDefinitionResponseEither.right().value());
-                }
-            }
-        }
-        return  Either.left(Boolean.TRUE);
+    private void updateOperationInputDefs(org.openecomp.sdc.be.model.Component component,
+            Collection<Operation> interfaceOperations) {
+        interfaceOperations.stream().filter(operation -> Objects.nonNull(operation.getInputs())).forEach(
+                operation -> operation.getInputs().getListToscaDataDefinition().forEach(
+                        inp -> component.getInputs().stream().filter(in -> inp.getInputId().equals(in.getUniqueId()))
+                                       .forEach(in -> {
+                                           inp.setDefaultValue(in.getDefaultValue());
+                                           inp.setValue(in.getValue());
+                                           inp.setSchema(in.getSchema());
+                                       })));
     }
-    private Either<InterfaceDefinition, ResponseFormat > updateInterfaceDefinition(org.openecomp.sdc.be.model.Component oldComponent,
-                                        org.openecomp.sdc.be.model.Component newComponent,
-                                        InterfaceDefinition interfaceDefinition) {
-                        InterfaceUtils.createInterfaceToscaResourceName(newComponent.getName());
-                interfaceDefinition.setToscaResourceName(InterfaceUtils
-                        .createInterfaceToscaResourceName(newComponent.getName()));
-        try {
-            Either<InterfaceDefinition, StorageOperationStatus> interfaceUpdate = interfaceOperation
-                    .updateInterface(oldComponent.getUniqueId(), interfaceDefinition);
-            if (interfaceUpdate.isRight()) {
-                LOGGER.error("Failed to Update interface {}. Response is {}. ", newComponent.getName(), interfaceUpdate.right().value());
-                titanDao.rollback();
-                return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(interfaceUpdate.right().value(), ComponentTypeEnum.RESOURCE)));
-            }
-        } catch (Exception e) {
-            LOGGER.error("Exception occurred during update interface toscaResourceName  : {}", e);
-            titanDao.rollback();
-            return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
-        }
-        return Either.left( interfaceDefinition);
+
+    private void addOperationToInterface(InterfaceDefinition interfaceDefinition, Operation interfaceOperation) {
+        interfaceOperation.setUniqueId(UUID.randomUUID().toString());
+        interfaceOperation.setImplementation(createArtifactDefinition(UUID.randomUUID().toString()));
+        interfaceDefinition.getOperations()
+                .put(interfaceOperation.getUniqueId(), new OperationDataDefinition(interfaceOperation));
     }
 
-    public Either<Map<String, InterfaceDefinition>, ResponseFormat> getAllInterfaceLifecycleTypes() {
+    private void updateOperationOnInterface(InterfaceDefinition interfaceDefinition, Operation interfaceOperation,
+            String artifactUuId) {
+        interfaceOperation.setImplementation(createArtifactDefinition(artifactUuId));
+        interfaceDefinition.getOperations()
+                .put(interfaceOperation.getUniqueId(), new OperationDataDefinition(interfaceOperation));
+    }
 
-        Either<Map<String, InterfaceDefinition>, StorageOperationStatus> interfaceLifecycleTypes = interfaceLifecycleOperation.getAllInterfaceLifecycleTypes();
-        if(interfaceLifecycleTypes.isRight()) {
-            return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_LIFECYCLE_TYPES_NOT_FOUND));
-        }
-        interfaceLifecycleTypes.left().value().values().stream().forEach(
-            id -> id.setOperations(id.getOperations().keySet().stream().collect(Collectors.toMap(key -> key.replaceFirst(id.getUniqueId()+".",""), i -> id.getOperations().get(i)))));
+    private ArtifactDefinition createArtifactDefinition(String artifactUuId) {
+        ArtifactDefinition artifactDefinition = new ArtifactDefinition();
+        artifactDefinition.setArtifactUUID(artifactUuId);
+        artifactDefinition.setUniqueId(artifactUuId);
+        artifactDefinition.setArtifactType(ArtifactTypeEnum.WORKFLOW.getType());
+        artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
+        return artifactDefinition;
+    }
 
-        return Either.left(interfaceLifecycleTypes.left().value());
+    public Either<List<InterfaceDefinition>, ResponseFormat> updateInterfaceOperation(String componentId,
+            List<InterfaceDefinition> interfaceDefinitions, User user, boolean lock) {
+        return createOrUpdateInterfaceOperation(componentId, interfaceDefinitions, user, true,
+                UPDATE_INTERFACE_OPERATION, lock);
     }
+
 }
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogic.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogic.java
index 7917a0aa5d..4e842928ef 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogic.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogic.java
@@ -3984,14 +3984,6 @@ public class ResourceBusinessLogic extends ComponentBusinessLogic {
                 newResource.setDerivedFrom(null);
             }
 
-            Either<Boolean, ResponseFormat> validateAndUpdateInterfacesEither =
-                    interfaceOperationBusinessLogic.validateComponentNameAndUpdateInterfaces(currentResource, newResource);
-            if (validateAndUpdateInterfacesEither.isRight()) {
-                log.error("failed to validate and update Interfaces");
-                rollbackNeeded = true;
-                throw new ComponentException(validateAndUpdateInterfacesEither.right().value());
-            }
-
             Either<Resource, ResponseFormat> dataModelResponse = updateResourceMetadata(resourceIdToUpdate, newResource,
                     user, currentResource, false, true);
             if (dataModelResponse.isRight()) {
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ServiceBusinessLogic.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ServiceBusinessLogic.java
index e85afdc48f..8d4f896d47 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ServiceBusinessLogic.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ServiceBusinessLogic.java
@@ -518,11 +518,7 @@ public class ServiceBusinessLogic extends ComponentBusinessLogic {
             log.info("Restricted operation for user: {}, on service: {}", user.getUserId(), currentService.getCreatorUserId());
             return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
         }
-        Either<Boolean, ResponseFormat> validateAndUpdateInterfacesEither = interfaceOperationBusinessLogic.validateComponentNameAndUpdateInterfaces(currentService, serviceUpdate);
-        if (validateAndUpdateInterfacesEither.isRight()) {
-            log.info("failed to validate and update Interfaces on service {}", currentService.getCreatorUserId());
-            return Either.right(validateAndUpdateInterfacesEither.right().value());
-        }
+
         Either<Service, ResponseFormat> validationRsponse = validateAndUpdateServiceMetadata(user, currentService, serviceUpdate);
         if (validationRsponse.isRight()) {
             log.info("service update metadata: validations field.");
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
new file mode 100644
index 0000000000..0233711a89
--- /dev/null
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/utils/InterfaceOperationUtils.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.openecomp.sdc.be.components.utils;
+
+import java.util.Map;
+import java.util.Optional;
+import org.apache.commons.collections.MapUtils;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.InterfaceDefinition;
+import org.openecomp.sdc.be.model.Operation;
+
+public class InterfaceOperationUtils {
+
+    private InterfaceOperationUtils() {
+    }
+
+    public static Optional<InterfaceDefinition> getInterfaceDefinitionFromComponentByInterfaceType(Component component,
+            String interfaceType) {
+        if (MapUtils.isEmpty(component.getInterfaces())) {
+            return Optional.empty();
+        }
+        return component.getInterfaces().values().stream()
+                       .filter(interfaceDefinition -> interfaceDefinition.getType() != null && interfaceDefinition
+                                                                                                       .getType()
+                                                                                                       .equals(interfaceType))
+                       .findAny();
+    }
+
+    public static Optional<InterfaceDefinition> getInterfaceDefinitionFromComponentByInterfaceId(Component component,
+            String interfaceId) {
+        if (MapUtils.isEmpty(component.getInterfaces())) {
+            return Optional.empty();
+        }
+        return component.getInterfaces().values().stream()
+                       .filter(interfaceDefinition -> interfaceDefinition.getUniqueId() != null && interfaceDefinition
+                                                                                                           .getUniqueId()
+                                                                                                           .equals(interfaceId))
+                       .findAny();
+    }
+
+    public static Optional<Map.Entry<String, Operation>> getOperationFromInterfaceDefinition(
+            InterfaceDefinition interfaceDefinition, String operationId) {
+        if (MapUtils.isEmpty(interfaceDefinition.getOperationsMap())) {
+            return Optional.empty();
+        }
+        return interfaceDefinition.getOperationsMap().entrySet().stream()
+                       .filter(entry -> entry.getValue().getUniqueId().equals(operationId)).findAny();
+    }
+
+}
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 7b650e4fad..c80f57486d 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,6 +16,7 @@
 
 package org.openecomp.sdc.be.components.validation;
 
+import fj.data.Either;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -25,16 +26,11 @@ import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.regex.Pattern;
-import java.util.stream.Collectors;
-
-import fj.data.Either;
+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.elasticsearch.common.Strings;
 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.OperationInputDefinition;
 import org.openecomp.sdc.be.model.InputDefinition;
 import org.openecomp.sdc.be.model.InterfaceDefinition;
@@ -47,272 +43,339 @@ import org.springframework.stereotype.Component;
 @Component("interfaceOperationValidation")
 public class InterfaceOperationValidation {
 
-    private static final String TYPE_VALIDATION_REGEX = "^[a-zA-Z]{1,200}$";
-    private static final int DESCRIPTION_MAX_LENGTH = 200;
+    private static final String TYPE_VALIDATION_REGEX = "^[a-zA-Z0-9_]{1,200}$";
 
     private static final Logger LOGGER = LoggerFactory.getLogger(InterfaceOperationValidation.class);
 
-    public Either<Boolean, ResponseFormat> validateInterfaceOperations(
-        Collection<Operation> interfaceOperations, org.openecomp.sdc.be.model.Component component, 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,
+                        globalInterfaceTypes, isUpdate);
+        if (validateAllowedOperationCountOnLocalInterfaceType.isRight()) {
+            return validateAllowedOperationCountOnLocalInterfaceType;
+        }
+
+        Either<Boolean, ResponseFormat> validateAllowedOperationsOnGlobalInterfaceType =
+                validateAllowedOperationsOnGlobalInterfaceType(inputInterfaceDefinition, globalInterfaceTypes);
+        if (validateAllowedOperationsOnGlobalInterfaceType.isRight()) {
+            return validateAllowedOperationsOnGlobalInterfaceType;
+        }
 
-        for(Operation interfaceOperation : interfaceOperations) {
-            Either<Boolean, ResponseFormat> interfaceOperationValidatorResponse = validateInterfaceOperation(
-                interfaceOperation, component, isUpdate);
+        Either<Boolean, ResponseFormat> validateOperationNameUniqueness =
+                validateOperationNameUniquenessInCollection(inputInterfaceDefinition.getOperationsMap().values());
+        if (validateOperationNameUniqueness.isRight()) {
+            return validateOperationNameUniqueness;
+        }
+
+        for (Operation interfaceOperation : inputInterfaceDefinition.getOperationsMap().values()) {
+            Either<Boolean, ResponseFormat> interfaceOperationValidatorResponse =
+                    validateInterfaceOperation(interfaceOperation, storedInterfaceDefinition, component, isUpdate);
             if (interfaceOperationValidatorResponse.isRight()) {
                 return interfaceOperationValidatorResponse;
             }
         }
+
         return Either.left(Boolean.TRUE);
     }
 
-    private Either<Boolean, ResponseFormat> validateInterfaceOperation(Operation interfaceOperation,
-        org.openecomp.sdc.be.model.Component component, boolean isUpdate) {
-        ResponseFormatManager responseFormatManager = getResponseFormatManager();
+    private Either<Boolean, ResponseFormat> validateAllowedOperationCountOnLocalInterfaceType(
+            InterfaceDefinition inputInterfaceDefinition, InterfaceDefinition storedInterfaceDefinition,
+            Map<String, InterfaceDefinition> globalInterfaceTypes, boolean isUpdate) {
+
+        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())))) {
+            return Either.right(getResponseFormatManager()
+                                        .getResponseFormat(ActionStatus.INTERFACE_OPERATION_INVALID_FOR_LOCAL_TYPE,
+                                                inputInterfaceDefinition.getType()));
+        }
 
-        Either<Boolean, ResponseFormat> interfaceOperationTypeResponse = isInterfaceOperationTypeValid(interfaceOperation,
-            responseFormatManager, component, isUpdate);
-        if (interfaceOperationTypeResponse.isRight()) {
-            return Either.right(interfaceOperationTypeResponse.right().value());
+        return Either.left(Boolean.TRUE);
+    }
+
+    private Either<Boolean, ResponseFormat> validateAllowedOperationsOnGlobalInterfaceType(
+            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)));
+            if (!isOperationValidOnGlobalInterfaceType) {
+                return Either.right(getResponseFormatManager()
+                                            .getResponseFormat(ActionStatus.INTERFACE_OPERATION_INVALID_FOR_GLOBAL_TYPE,
+                                                    interfaceDefinition.getType()));
+            }
         }
+        return Either.left(Boolean.TRUE);
+    }
 
-        Either<Boolean, ResponseFormat> descriptionResponseEither = isValidDescription(responseFormatManager,
-            interfaceOperation.getDescription());
-        if (descriptionResponseEither.isRight()) {
-            return Either.right(descriptionResponseEither.right().value());
+    private Either<Boolean, ResponseFormat> validateOperationNameUniquenessInCollection(
+            Collection<Operation> operationList) {
+        HashSet<String> operationNames = new HashSet<>();
+        for (Operation operation : operationList) {
+            if (!operationNames.add(operation.getName())) {
+                return Either.right(getResponseFormatManager()
+                                            .getResponseFormat(ActionStatus.INTERFACE_OPERATION_NAME_ALREADY_IN_USE,
+                                                    operation.getName()));
+            }
         }
+        return Either.left(Boolean.TRUE);
+    }
 
-        Either<Boolean, ResponseFormat> inputPropertyExistInComponent = validateInputPropertyExistInComponent(interfaceOperation,
-                component.getInputs(), responseFormatManager);
-        if(inputPropertyExistInComponent.isRight()) {
-            return Either.right(inputPropertyExistInComponent.right().value());
+    private Either<Boolean, ResponseFormat> validateInterfaceOperation(Operation interfaceOperation,
+            InterfaceDefinition interfaceDefinition, org.openecomp.sdc.be.model.Component component, boolean isUpdate) {
 
+        ResponseFormatManager responseFormatManager = getResponseFormatManager();
+        Either<Boolean, ResponseFormat> interfaceOperationTypeResponse =
+                isInterfaceOperationTypeValid(interfaceOperation, responseFormatManager, interfaceDefinition, isUpdate);
+        if (interfaceOperationTypeResponse.isRight()) {
+            return Either.right(interfaceOperationTypeResponse.right().value());
         }
 
-        Either<Boolean, ResponseFormat> inputParametersResponse = validateInputParameters(interfaceOperation,
-            responseFormatManager);
-        if(inputParametersResponse.isRight()) {
-            return Either.right(inputParametersResponse.right().value());
+        if (null != interfaceOperation.getInputs()) {
+            Either<Boolean, ResponseFormat> inputParametersResponse =
+                    validateInputParameters(interfaceOperation, responseFormatManager);
+            if (inputParametersResponse.isRight()) {
+                return Either.right(inputParametersResponse.right().value());
+            }
+
+            Either<Boolean, ResponseFormat> inputPropertyExistInComponent =
+                    validateInputPropertyExistInComponent(interfaceOperation, component, responseFormatManager);
+            if (inputPropertyExistInComponent.isRight()) {
+                return Either.right(inputPropertyExistInComponent.right().value());
+
+            }
         }
 
-        Either<Boolean, ResponseFormat> outputParametersResponse = validateOutputParameters(interfaceOperation,
-            responseFormatManager);
-        if(outputParametersResponse.isRight()) {
-            return Either.right(outputParametersResponse.right().value());
+        if (null != interfaceOperation.getOutputs()) {
+            Either<Boolean, ResponseFormat> outputParametersResponse =
+                    validateOutputParameters(interfaceOperation, responseFormatManager);
+            if (outputParametersResponse.isRight()) {
+                return Either.right(outputParametersResponse.right().value());
+            }
         }
 
         return Either.left(Boolean.TRUE);
     }
 
+    protected ResponseFormatManager getResponseFormatManager() {
+        return ResponseFormatManager.getInstance();
+    }
+
     private Either<Boolean, ResponseFormat> isInterfaceOperationTypeValid(Operation interfaceOperation,
-        ResponseFormatManager responseFormatManager,
-        org.openecomp.sdc.be.model.Component component, boolean isUpdate) {
+            ResponseFormatManager responseFormatManager, InterfaceDefinition interfaceDefinition, boolean isUpdate) {
 
         Either<Boolean, ResponseFormat> operationTypeEmptyEither =
-            isOperationTypeEmpty(responseFormatManager, interfaceOperation.getName());
+                isOperationTypeEmpty(responseFormatManager, interfaceOperation.getName());
         if (operationTypeEmptyEither.isRight()) {
             return Either.right(operationTypeEmptyEither.right().value());
         }
 
         Either<Boolean, ResponseFormat> operationTypeRegexValidationResponse =
-            isOperationTypeRegexValid(responseFormatManager, interfaceOperation.getName());
+                isOperationTypeRegexValid(responseFormatManager, interfaceOperation.getName());
         if (operationTypeRegexValidationResponse.isRight()) {
             return Either.right(operationTypeRegexValidationResponse.right().value());
         }
 
-        Either<Boolean, ResponseFormat> operationTypeUniqueResponse = validateOperationTypeUnique(interfaceOperation,
-            component, isUpdate );
-        if(operationTypeUniqueResponse.isRight()) {
+        Either<Boolean, ResponseFormat> operationTypeUniqueResponse =
+                validateOperationTypeUnique(interfaceOperation, interfaceDefinition, isUpdate);
+        if (operationTypeUniqueResponse.isRight()) {
             return Either.right(operationTypeUniqueResponse.right().value());
         }
         if (!operationTypeUniqueResponse.left().value()) {
             LOGGER.error("Interface Operation type  {} already in use ", interfaceOperation.getName());
-            ResponseFormat errorResponse = responseFormatManager.getResponseFormat(ActionStatus
-                .INTERFACE_OPERATION_NAME_ALREADY_IN_USE, interfaceOperation.getName());
+            ResponseFormat errorResponse = responseFormatManager.getResponseFormat(
+                    ActionStatus.INTERFACE_OPERATION_NAME_ALREADY_IN_USE, interfaceOperation.getName());
             return Either.right(errorResponse);
         }
         return Either.left(Boolean.TRUE);
     }
 
-    private Either<Boolean, ResponseFormat> isOperationTypeRegexValid(ResponseFormatManager responseFormatManager,
-        String operationType) {
-        if (!isValidOperationType(operationType)) {
-            LOGGER.error("Interface Operation type {} is invalid, Operation type should not contain" +
-                "Special character, space, numbers and  should not be greater than 200 characters", operationType);
-            ResponseFormat errorResponse = responseFormatManager.getResponseFormat(ActionStatus
-                .INTERFACE_OPERATION_NAME_INVALID, operationType);
-            return Either.right(errorResponse);
+    private Either<Boolean, ResponseFormat> validateInputParameters(Operation interfaceOperation,
+            ResponseFormatManager responseFormatManager) {
+        if (isInputParameterNameEmpty(interfaceOperation)) {
+            LOGGER.error("Interface operation input parameter name can't be empty");
+            ResponseFormat inputResponse =
+                    responseFormatManager.getResponseFormat(ActionStatus.INTERFACE_OPERATION_INPUT_NAME_MANDATORY);
+            return Either.right(inputResponse);
+        }
+
+        Either<Boolean, Set<String>> validateInputParametersUniqueResponse =
+                isInputParametersUnique(interfaceOperation);
+        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());
+            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) {
+        if (isOutputParameterNameEmpty(interfaceOperation)) {
+            LOGGER.error("Interface operation output parameter name can't be empty");
+            ResponseFormat inputResponse =
+                    responseFormatManager.getResponseFormat(ActionStatus.INTERFACE_OPERATION_OUTPUT_NAME_MANDATORY);
+            return Either.right(inputResponse);
+        }
+
+        Either<Boolean, Set<String>> validateOutputParametersUniqueResponse =
+                isOutputParametersUnique(interfaceOperation);
+        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());
+            return Either.right(inputResponse);
         }
         return Either.left(Boolean.TRUE);
     }
 
     private Either<Boolean, ResponseFormat> isOperationTypeEmpty(ResponseFormatManager responseFormatManager,
-        String operationType) {
+            String operationType) {
         if (StringUtils.isEmpty(operationType)) {
             LOGGER.error("Interface Operation type is mandatory");
-            ResponseFormat errorResponse = responseFormatManager.getResponseFormat(ActionStatus
-                .INTERFACE_OPERATION_NAME_MANDATORY);
+            ResponseFormat errorResponse =
+                    responseFormatManager.getResponseFormat(ActionStatus.INTERFACE_OPERATION_NAME_MANDATORY);
             return Either.right(errorResponse);
         }
         return Either.left(Boolean.TRUE);
     }
 
-    private Either<Boolean, ResponseFormat> isValidDescription(ResponseFormatManager responseFormatManager,
-        String description) {
-        if (!Strings.isNullOrEmpty(description) && description.length() > DESCRIPTION_MAX_LENGTH) {
-            LOGGER.error("Interface Operation description {} is invalid, maximum 200 characters allowed", description);
-            ResponseFormat errorResponse = responseFormatManager.getResponseFormat(ActionStatus
-                .INTERFACE_OPERATION_DESCRIPTION_MAX_LENGTH, description);
+    private Either<Boolean, ResponseFormat> isOperationTypeRegexValid(ResponseFormatManager responseFormatManager,
+            String operationType) {
+        if (!isValidOperationType(operationType)) {
+            LOGGER.error("Interface Operation type {} is invalid, Operation type should not contain"
+                                 + "Special character, space, numbers and  should not be greater than 200 characters",
+                    operationType);
+            ResponseFormat errorResponse = responseFormatManager
+                                                   .getResponseFormat(ActionStatus.INTERFACE_OPERATION_NAME_INVALID,
+                                                           operationType);
             return Either.right(errorResponse);
         }
         return Either.left(Boolean.TRUE);
     }
 
-    private boolean isValidOperationType(String operationType) {
-        return Pattern.matches(TYPE_VALIDATION_REGEX, operationType);
-    }
-
-    private Either<Boolean, ResponseFormat> validateOperationTypeUnique(
-        Operation interfaceOperation,
-        org.openecomp.sdc.be.model.Component component,
-        boolean isUpdate) {
+    private Either<Boolean, ResponseFormat> validateOperationTypeUnique(Operation interfaceOperation,
+            InterfaceDefinition interfaceDefinition, boolean isUpdate) {
         boolean isOperationTypeUnique = false;
 
-        Map<String, InterfaceDefinition> interfaceDefinitionMap = component.getInterfaces();
-        if(interfaceDefinitionMap.isEmpty()){
-            return Either.left(true);
-        }
-
-        Collection<Operation> allOperations = interfaceDefinitionMap.values().stream()
-            .filter(a -> MapUtils.isNotEmpty(a.getOperationsMap()))
-            .map(a -> a.getOperationsMap().values()).flatMap(Collection::stream)
-            .collect(Collectors.toList());
-        if(CollectionUtils.isEmpty(allOperations)){
+        if (interfaceDefinition == null || CollectionUtils.isEmpty(interfaceDefinition.getOperationsMap().values())) {
             return Either.left(true);
         }
 
         Map<String, String> operationTypes = new HashMap<>();
-        allOperations.forEach(operationType -> operationTypes.put(operationType.getUniqueId(), operationType.getName()));
+        interfaceDefinition.getOperationsMap().values()
+                .forEach(operationType -> operationTypes.put(operationType.getUniqueId(), operationType.getName()));
 
-        if (!operationTypes.values().contains(interfaceOperation.getName())){
+        if (!operationTypes.values().contains(interfaceOperation.getName())) {
             isOperationTypeUnique = true;
         }
-        if (!isOperationTypeUnique && isUpdate){
-            Optional<String> id = operationTypes.entrySet().stream().filter(entry -> Objects.equals(entry.getValue(), interfaceOperation.getName()))
-                .map(Map.Entry::getKey).findAny();
-            if(id.isPresent() && id.get().equalsIgnoreCase(interfaceOperation.getUniqueId())){
+        if (!isOperationTypeUnique && isUpdate) {
+            Optional<String> id = operationTypes.entrySet().stream().filter(entry -> Objects.equals(entry.getValue(),
+                    interfaceOperation.getName())).map(Map.Entry::getKey).findAny();
+            if (id.isPresent() && id.get().equalsIgnoreCase(interfaceOperation.getUniqueId())) {
                 isOperationTypeUnique = true;
             }
         }
 
         return Either.left(isOperationTypeUnique);
     }
-    private Either<Boolean, ResponseFormat> validateInputParameters(Operation interfaceOperation,
-        ResponseFormatManager responseFormatManager) {
-        if (isInputParameterNameEmpty(interfaceOperation)) {
-            LOGGER.error("Interface operation input parameter name can't be empty");
-            ResponseFormat inputResponse = responseFormatManager.getResponseFormat(ActionStatus.INTERFACE_OPERATION_INPUT_NAME_MANDATORY);
-            return Either.right(inputResponse);
-        }
 
-        Either<Boolean, Set<String>> validateInputParametersUniqueResponse = isInputParametersUnique(interfaceOperation);
-        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());
-            return Either.right(inputResponse);
-        }
-        return Either.left(Boolean.TRUE);
+    private Boolean isInputParameterNameEmpty(Operation operationDataDefinition) {
+        return operationDataDefinition.getInputs().getListToscaDataDefinition().stream().anyMatch(
+                inputParam -> inputParam.getName() == null || inputParam.getName().trim().equals(StringUtils.EMPTY));
     }
 
-
-    private Either<Boolean, ResponseFormat> validateOutputParameters(Operation interfaceOperation,
-        ResponseFormatManager responseFormatManager) {
-        if (isOutputParameterNameEmpty(interfaceOperation)) {
-            LOGGER.error("Interface operation output parameter name can't be empty");
-            ResponseFormat inputResponse = responseFormatManager.getResponseFormat(ActionStatus.INTERFACE_OPERATION_OUTPUT_NAME_MANDATORY);
-            return Either.right(inputResponse);
-        }
-
-        Either<Boolean, Set<String>> validateOutputParametersUniqueResponse = isOutputParametersUnique(interfaceOperation);
-        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());
-            return Either.right(inputResponse);
-        }
-        return Either.left(Boolean.TRUE);
-    }
     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());
-                }
-            });
-        if(!duplicateParamNamesToReturn.isEmpty()) {
+        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 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());
-                }
-            });
-        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 isInputParameterNameEmpty(Operation operationDataDefinition) {
-        return operationDataDefinition.getInputs().getListToscaDataDefinition().stream()
-            .anyMatch(inputParam -> inputParam.getName() == null || inputParam.getName().trim().equals(StringUtils.EMPTY));
-    }
     private Boolean isOutputParameterNameEmpty(Operation operationDataDefinition) {
-        return operationDataDefinition.getOutputs().getListToscaDataDefinition().stream()
-            .anyMatch(outputParam -> outputParam.getName() == null || outputParam.getName().trim().equals(StringUtils.EMPTY));
+        return operationDataDefinition.getOutputs().getListToscaDataDefinition().stream().anyMatch(
+                outputParam -> outputParam.getName() == null || outputParam.getName().trim().equals(StringUtils.EMPTY));
     }
 
-    private  Either<Boolean, ResponseFormat> validateInputPropertyExistInComponent(Operation operation,
-                                                    List<InputDefinition> inputs,
-                                                    ResponseFormatManager responseFormatManager) {
-        ListDataDefinition<OperationInputDefinition> inputDefinitionListDataDefinition = operation.getInputs();
-        if (inputDefinitionListDataDefinition == null) {
-            return Either.left(Boolean.TRUE);
-        }
-        List<OperationInputDefinition> inputListToscaDataDefinition = inputDefinitionListDataDefinition.getListToscaDataDefinition();
-
-        for(OperationInputDefinition inputDefinition : inputListToscaDataDefinition ) {
-            if(!validateInputExistsInComponent(inputDefinition, inputs)) {
-                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);
-                return Either.right(inputResponse);
+    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());
             }
+        });
+        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 ResponseFormatManager getResponseFormatManager() {
-        return ResponseFormatManager.getInstance();
+    private boolean isValidOperationType(String operationType) {
+        return Pattern.matches(TYPE_VALIDATION_REGEX, operationType);
     }
 
 }
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/datamodel/utils/InterfaceUIDataConverter.java b/catalog-be/src/main/java/org/openecomp/sdc/be/datamodel/utils/InterfaceUIDataConverter.java
deleted file mode 100644
index 7fbc56a624..0000000000
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/datamodel/utils/InterfaceUIDataConverter.java
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
- * Copyright © 2016-2018 European Support Limited
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.openecomp.sdc.be.datamodel.utils;
-
-import org.openecomp.sdc.be.datatypes.elements.InterfaceOperationDataDefinition;
-import org.openecomp.sdc.be.datatypes.elements.InterfaceOperationParamDataDefinition;
-import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
-import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
-import org.openecomp.sdc.be.datatypes.elements.OperationOutputDefinition;
-import org.openecomp.sdc.be.model.Operation;
-
-import java.util.List;
-import java.util.stream.Collectors;
-
-public class InterfaceUIDataConverter {
-
-  private InterfaceUIDataConverter () {
-
-  }
-  public static Operation convertInterfaceDataToOperationData(InterfaceOperationDataDefinition interfaceOperation){
-
-    ListDataDefinition<InterfaceOperationParamDataDefinition> inputParams = interfaceOperation.getInputParams();
-    ListDataDefinition<OperationInputDefinition> inputs = new ListDataDefinition<>();
-    if (inputParams != null) {
-      List<OperationInputDefinition> inputList = inputParams.getListToscaDataDefinition().stream()
-              .map(interfaceOperationParamDataDefinition -> new OperationInputDefinition(
-                      interfaceOperationParamDataDefinition.getName(),
-                      interfaceOperationParamDataDefinition.getProperty(),
-                      interfaceOperationParamDataDefinition.getMandatory() == null ? false : interfaceOperationParamDataDefinition.getMandatory(),
-                      interfaceOperationParamDataDefinition.getType()
-                      )).collect(Collectors.toList());
-      inputList.forEach(inputs::add);
-    }
-    ListDataDefinition<InterfaceOperationParamDataDefinition> outputParams = interfaceOperation.getOutputParams();
-    ListDataDefinition<OperationOutputDefinition> outputs = new ListDataDefinition<>();
-    if(outputParams != null) {
-      List<OperationOutputDefinition> outputList = outputParams.getListToscaDataDefinition().stream()
-              .map(interfaceOperationParamDataDefinition -> new OperationOutputDefinition(
-                      interfaceOperationParamDataDefinition.getName(),
-                      interfaceOperationParamDataDefinition.getMandatory() == null ? false : interfaceOperationParamDataDefinition.getMandatory(),
-                      interfaceOperationParamDataDefinition.getType()
-                      )).collect(Collectors.toList());
-      outputList.forEach(outputs::add);
-    }
-
-    Operation operationData = new Operation();
-    operationData.setDescription(interfaceOperation.getDescription());
-    operationData.setName(interfaceOperation.getOperationType());
-    operationData.setUniqueId(interfaceOperation.getUniqueId());
-    operationData.setInputs(inputs);
-    operationData.setOutputs(outputs);
-    operationData.setWorkflowId(interfaceOperation.getWorkflowId());
-    operationData.setWorkflowVersionId(interfaceOperation.getWorkflowVersionId());
-    operationData.setWorkflowAssociationType(interfaceOperation.getWorkflowAssociationType());
-
-    return operationData;
-  }
-
-  public static InterfaceOperationDataDefinition convertOperationDataToInterfaceData(Operation operationData){
-    ListDataDefinition<OperationInputDefinition> inputs = operationData.getInputs();
-    List<InterfaceOperationParamDataDefinition> inputParamList = inputs.getListToscaDataDefinition().stream()
-            .map(operationInputDefinition -> new InterfaceOperationParamDataDefinition(operationInputDefinition.getName(),
-                    operationInputDefinition.getInputId(),
-                    operationInputDefinition.isRequired(),
-                    operationInputDefinition.getType())).collect(
-            Collectors.toList());
-    ListDataDefinition<InterfaceOperationParamDataDefinition> inputParams = new ListDataDefinition<>();
-    inputParamList.forEach(inputParams::add);
-
-    ListDataDefinition<OperationOutputDefinition> outputs = operationData.getOutputs();
-    List<InterfaceOperationParamDataDefinition> outputParamList = outputs.getListToscaDataDefinition()
-            .stream().map(operationOutputDefinition -> new InterfaceOperationParamDataDefinition(operationOutputDefinition.getName(),
-                    operationOutputDefinition.isRequired(),
-                    operationOutputDefinition.getType())).collect(Collectors.toList());
-    ListDataDefinition<InterfaceOperationParamDataDefinition> outputParams = new ListDataDefinition<>();
-    outputParamList.forEach(outputParams::add);
-
-    InterfaceOperationDataDefinition interfaceOperationDataDefinition = new InterfaceOperationDataDefinition();
-    interfaceOperationDataDefinition.setUniqueId(operationData.getUniqueId());
-    interfaceOperationDataDefinition.setOperationType(operationData.getName());
-    interfaceOperationDataDefinition.setDescription(operationData.getDescription());
-    interfaceOperationDataDefinition.setInputParams(inputParams);
-    interfaceOperationDataDefinition.setOutputParams(outputParams);
-    interfaceOperationDataDefinition.setArtifactUUID(operationData.getImplementation().getArtifactUUID());
-    interfaceOperationDataDefinition.setWorkflowId(operationData.getWorkflowId());
-    interfaceOperationDataDefinition.setWorkflowVersionId(operationData.getWorkflowVersionId());
-    interfaceOperationDataDefinition.setWorkflowAssociationType(operationData.getWorkflowAssociationType());
-
-    return interfaceOperationDataDefinition;
-  }
-
-}
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/externalapi/servlet/ArtifactExternalServlet.java b/catalog-be/src/main/java/org/openecomp/sdc/be/externalapi/servlet/ArtifactExternalServlet.java
index 03c5e0fbf1..bc2ebbfb14 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/externalapi/servlet/ArtifactExternalServlet.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/externalapi/servlet/ArtifactExternalServlet.java
@@ -25,7 +25,6 @@ import com.jcabi.aspects.Loggable;
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
-import java.util.EnumMap;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -70,12 +69,7 @@ import javax.ws.rs.core.Context;
 import javax.ws.rs.core.HttpHeaders;
 import javax.ws.rs.core.MediaType;
 import javax.ws.rs.core.Response;
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.EnumMap;
-import java.util.HashMap;
-import java.util.Map;
+
 /**
  * This Servlet serves external users operations on artifacts.
  *
@@ -98,7 +92,7 @@ public class ArtifactExternalServlet extends AbstractValidationsServlet {
     private static String startLog = "Start handle request of ";
 
     @POST
-    @Path("/{assetType}/{uuid}/interfaces/{operationUUID}/artifacts/{artifactUUID}")
+    @Path("/{assetType}/{uuid}/interfaces/{interfaceUUID}/operations/{operationUUID}/artifacts/{artifactUUID}")
     @Produces(MediaType.APPLICATION_JSON)
     @ApiOperation(value = "uploads of artifact to VF operation workflow", httpMethod = "POST", notes = "uploads of artifact to VF operation workflow")
     @ApiResponses(value = {
@@ -127,6 +121,7 @@ public class ArtifactExternalServlet extends AbstractValidationsServlet {
             @ApiParam(value = "The username and password", required = true) @HeaderParam(value = Constants.AUTHORIZATION_HEADER) String authorization,
             @ApiParam(value = "Asset type") @PathParam("assetType") String assetType,
             @ApiParam(value = "The uuid of the asset as published in the metadata", required = true)@PathParam("uuid") final String uuid,
+            @ApiParam(value = "The uuid of the interface", required = true)@PathParam("interfaceUUID") final String interfaceUUID,
             @ApiParam(value = "The uuid of the operation", required = true)@PathParam("operationUUID") final String operationUUID,
             @ApiParam(value = "The uuid of the artifact", required = true)@PathParam("artifactUUID") final String artifactUUID,
             @ApiParam( hidden = true) String data) {
@@ -154,7 +149,7 @@ public class ArtifactExternalServlet extends AbstractValidationsServlet {
                 ArtifactsBusinessLogic artifactsLogic = getArtifactBL(context);
                 Either<ArtifactDefinition, ResponseFormat> uploadArtifactEither = artifactsLogic
                         .updateArtifactOnInterfaceOperationByResourceUUID(data, request, ComponentTypeEnum
-                                        .findByParamName(assetType), uuid,  artifactUUID, operationUUID,
+                                        .findByParamName(assetType), uuid, interfaceUUID, operationUUID, artifactUUID,
                         resourceCommonInfo, artifactsLogic.new ArtifactOperationInfo(true, false, ArtifactOperationEnum.UPDATE));
                 if (uploadArtifactEither.isRight()) {
                     log.debug(FAILED_TO_UPDATE_ARTIFACT);
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/InterfaceOperationServlet.java b/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/InterfaceOperationServlet.java
index 815f9763f9..801572d2f1 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/InterfaceOperationServlet.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/InterfaceOperationServlet.java
@@ -16,6 +16,7 @@
 
 package org.openecomp.sdc.be.servlets;
 
+import com.google.common.collect.ImmutableMap;
 import com.jcabi.aspects.Loggable;
 import fj.data.Either;
 import io.swagger.annotations.Api;
@@ -23,8 +24,12 @@ import io.swagger.annotations.ApiOperation;
 import io.swagger.annotations.ApiParam;
 import io.swagger.annotations.ApiResponse;
 import io.swagger.annotations.ApiResponses;
-import java.util.Optional;
-import java.util.UUID;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 import javax.inject.Singleton;
 import javax.servlet.ServletContext;
 import javax.servlet.http.HttpServletRequest;
@@ -43,10 +48,9 @@ import javax.ws.rs.core.Response;
 import org.openecomp.sdc.be.components.impl.InterfaceOperationBusinessLogic;
 import org.openecomp.sdc.be.config.BeEcompErrorManager;
 import org.openecomp.sdc.be.dao.api.ActionStatus;
-import org.openecomp.sdc.be.datamodel.utils.InterfaceUIDataConverter;
-import org.openecomp.sdc.be.datatypes.elements.InterfaceOperationDataDefinition;
 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
-import org.openecomp.sdc.be.model.Operation;
+import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
+import org.openecomp.sdc.be.model.InterfaceDefinition;
 import org.openecomp.sdc.be.model.User;
 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
 import org.openecomp.sdc.be.ui.model.UiComponentDataTransfer;
@@ -56,190 +60,270 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 @Loggable(prepend = true, value = Loggable.DEBUG, trim = false)
-@Path("/v1/catalog/{componentType}/{componentId}/interfaceOperations")
+@Path("/v1/catalog")
 @Consumes(MediaType.APPLICATION_JSON)
 @Produces(MediaType.APPLICATION_JSON)
-@Api(value = "Interface Operation", description = "Interface Operation Servlet")
+@Api(value = "Interface Operation Servlet", description = "Interface Operation Servlet")
 @Singleton
 public class InterfaceOperationServlet extends AbstractValidationsServlet {
 
-  private static final Logger log = LoggerFactory.getLogger(InterfaceOperationServlet.class);
-
-  @POST
-  @Consumes(MediaType.APPLICATION_JSON)
-  @Produces(MediaType.APPLICATION_JSON)
-  @Path("/")
-  @ApiOperation(value = "Create Interface Operation", httpMethod = "POST", notes = "Create Interface Operation", response = InterfaceOperationDataDefinition.class)
-  @ApiResponses(value = {@ApiResponse(code = 201, message = "Create Interface Operation"),
-      @ApiResponse(code = 403, message = "Restricted operation"),
-      @ApiResponse(code = 400, message = "Invalid content / Missing content"),
-      @ApiResponse(code = 409, message = "Interface Operation already exist")})
-  public Response createInterfaceOperation(
-      @ApiParam(value = "Interface Operation to create", required = true) String data,
-      @ApiParam(value = "Component type") @PathParam("componentType") String componentType,
-      @ApiParam(value = "Component Id") @PathParam("componentId") String componentId,
-      @Context final HttpServletRequest request,
-      @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
-    return createOrUpdate(data, componentType ,componentId, request, userId, false);
-  }
-
-  @PUT
-  @Consumes(MediaType.APPLICATION_JSON)
-  @Produces(MediaType.APPLICATION_JSON)
-  @Path("/")
-  @ApiOperation(value = "Update Interface Operation", httpMethod = "PUT", notes = "Update Interface Operation", response = InterfaceOperationDataDefinition.class)
-  @ApiResponses(value = {@ApiResponse(code = 201, message = "Update Interface Operation"),
-      @ApiResponse(code = 403, message = "Restricted operation"),
-      @ApiResponse(code = 400, message = "Invalid content / Missing content")})
-  public Response updateInterfaceOperation(
-      @ApiParam(value = "Interface Operation to update", required = true) String data,
-      @ApiParam(value = "Component type") @PathParam("componentType") String componentType,
-      @ApiParam(value = "Component Id") @PathParam("componentId") String componentId,
-      @Context final HttpServletRequest request,
-      @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
-    return createOrUpdate(data, componentType,componentId, request, userId, true);
-  }
-
-  @DELETE
-  @Consumes(MediaType.APPLICATION_JSON)
-  @Produces(MediaType.APPLICATION_JSON)
-  @Path("/{interfaceOperationId}")
-  @ApiOperation(value = "Delete Interface Operation", httpMethod = "DELETE", notes = "Delete Interface Operation", response = InterfaceOperationDataDefinition.class)
-  @ApiResponses(value = {@ApiResponse(code = 201, message = "Delete Interface Operation"),
-      @ApiResponse(code = 403, message = "Restricted operation"),
-      @ApiResponse(code = 400, message = "Invalid content / Missing content")})
-  public Response deleteInterfaceOperation(
-      @ApiParam(value = "Interface Operation Id") @PathParam("interfaceOperationId") String interfaceOperationId,
-      @ApiParam(value = "Component Id") @PathParam("componentId") String componentId,
-      @Context final HttpServletRequest request,
-      @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
-    return delete(interfaceOperationId, componentId, request, userId);
-  }
-
-  @GET
-  @Consumes(MediaType.APPLICATION_JSON)
-  @Produces(MediaType.APPLICATION_JSON)
-  @Path("/{interfaceOperationId}")
-  @ApiOperation(value = "Get Interface Operation", httpMethod = "GET", notes = "GET Interface Operation", response = InterfaceOperationDataDefinition.class)
-  @ApiResponses(value = {@ApiResponse(code = 201, message = "Get Interface Operation"),
-      @ApiResponse(code = 403, message = "Restricted operation"),
-      @ApiResponse(code = 400, message = "Invalid content / Missing content")})
-  public Response getInterfaceOperation(
-      @ApiParam(value = "Interface Operation Id") @PathParam("interfaceOperationId") String interfaceOperationId,
-      @ApiParam(value = "Component Id") @PathParam("componentId") String componentId,
-      @Context final HttpServletRequest request,
-      @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
-
-    return get(interfaceOperationId, componentId, request, userId);
-  }
-
-  private Response get (String interfaceOperationId,  String componentId, HttpServletRequest request, String userId){
-    ServletContext context = request.getSession().getServletContext();
-    String url = request.getMethod() + " " + request.getRequestURI();
-
-    User modifier = new User();
-    modifier.setUserId(userId);
-    log.debug("Start get request of {} with modifier id {}", url, userId);
-
-    try {
-      String componentIdLower = componentId.toLowerCase();
-      InterfaceOperationBusinessLogic businessLogic = getInterfaceOperationBL(context);
-
-      Either<Operation, ResponseFormat> actionResponse = businessLogic.getInterfaceOperation(componentIdLower, interfaceOperationId, modifier, true);
-      if (actionResponse.isRight()) {
-        log.error("failed to get interface operation");
-        return buildErrorResponse(actionResponse.right().value());
-      }
-
-      InterfaceOperationDataDefinition interfaceOperationDataDefinition = InterfaceUIDataConverter.convertOperationDataToInterfaceData(actionResponse.left().value());
-      Object result = RepresentationUtils.toFilteredRepresentation(interfaceOperationDataDefinition);
-      return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), result);
+    private static final Logger log = LoggerFactory.getLogger(InterfaceOperationServlet.class);
+
+    @POST
+    @Consumes(MediaType.APPLICATION_JSON)
+    @Produces(MediaType.APPLICATION_JSON)
+    @Path("/resources/{resourceId}/interfaceOperations")
+    @ApiOperation(value = "Create Interface Operations on Resource", httpMethod = "POST",
+            notes = "Create Interface Operations on Resource", response = InterfaceDefinition.class, responseContainer = "List")
+    @ApiResponses(value = {@ApiResponse(code = 201, message = "Create Interface Operations on Resource"),
+            @ApiResponse(code = 400, message = "Invalid content / Missing content"),
+            @ApiResponse(code = 403, message = "Restricted operation"),
+            @ApiResponse(code = 404, message = "Resource not found"),
+            @ApiResponse(code = 409, message = "Interface Operation already exist")})
+    public Response createInterfaceOperationsOnResource(
+            @ApiParam(value = "Interface Operations to create", required = true) String data,
+            @ApiParam(value = "Resource Id") @PathParam("resourceId") String resourceId,
+            @HeaderParam(value = Constants.USER_ID_HEADER) String userId, @Context final HttpServletRequest request) {
+        return createOrUpdate(data, ComponentTypeEnum.RESOURCE, resourceId, request, userId, false);
+    }
+
+    private Response createOrUpdate(String data, ComponentTypeEnum componentType, String componentId,
+            HttpServletRequest request, String userId, boolean isUpdate) {
+        ServletContext context = request.getSession().getServletContext();
+        String url = request.getMethod() + " " + request.getRequestURI();
+
+        User modifier = new User();
+        modifier.setUserId(userId);
+        log.debug("Start create or update request of {} with modifier id {}", url, userId);
+
+        try {
+            String componentIdLower = componentId.toLowerCase();
+            InterfaceOperationBusinessLogic businessLogic = getInterfaceOperationBL(context);
+
+            List<InterfaceDefinition> mappedInterfaceData = getMappedInterfaceData(data, modifier, componentType);
+            Either<List<InterfaceDefinition>, ResponseFormat> actionResponse;
+            if (isUpdate) {
+                actionResponse =
+                        businessLogic.updateInterfaceOperation(componentIdLower, mappedInterfaceData, modifier, true);
+            } else {
+                actionResponse =
+                        businessLogic.createInterfaceOperation(componentIdLower, mappedInterfaceData, modifier, true);
+            }
+
+            if (actionResponse.isRight()) {
+                log.error("failed to create or update interface operation");
+                return buildErrorResponse(actionResponse.right().value());
+            }
+
+            return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK),
+                    getFormattedResponse(actionResponse.left().value()));
+        } catch (Exception e) {
+            BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Interface Operation Creation or update");
+            log.error("create or update interface Operation with an error", e);
+            return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
+        }
+    }
+
+    private List<InterfaceDefinition> getMappedInterfaceData(String inputJson, User user,
+            ComponentTypeEnum componentTypeEnum) {
+        Either<UiComponentDataTransfer, ResponseFormat> uiComponentEither =
+                getComponentsUtils().convertJsonToObjectUsingObjectMapper(inputJson, user,
+                        UiComponentDataTransfer.class, AuditingActionEnum.CREATE_RESOURCE, componentTypeEnum);
+        return new ArrayList<>(uiComponentEither.left().value().getInterfaces().values());
     }
-    catch (Exception e) {
-      BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get Component interface operations");
-      log.error("get component interface operations failed with exception", e);
-      return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
+
+    private Object getFormattedResponse(List<InterfaceDefinition> interfaceDefinitions) throws IOException {
+        Map<String, List<InterfaceDefinition>> allInterfaces =
+                ImmutableMap.of(JsonPresentationFields.INTERFACES.getPresentation(), interfaceDefinitions);
+        return RepresentationUtils.toFilteredRepresentation(allInterfaces);
     }
-  }
 
-  private Response delete (String interfaceOperationId, String componentId, HttpServletRequest
-      request, String userId){
+    @PUT
+    @Consumes(MediaType.APPLICATION_JSON)
+    @Produces(MediaType.APPLICATION_JSON)
+    @Path("/resources/{resourceId}/interfaceOperations")
+    @ApiOperation(value = "Update Interface Operations on Resource", httpMethod = "PUT",
+            notes = "Update Interface Operations on Resource", response = InterfaceDefinition.class, responseContainer = "List")
+    @ApiResponses(value = {@ApiResponse(code = 201, message = "Update Interface Operations on Resource"),
+            @ApiResponse(code = 400, message = "Invalid content / Missing content"),
+            @ApiResponse(code = 403, message = "Restricted operation"),
+            @ApiResponse(code = 404, message = "Resource not found")})
+    public Response updateInterfaceOperationsOnResource(
+            @ApiParam(value = "Interface Operations to update", required = true) String data,
+            @ApiParam(value = "Resource Id") @PathParam("resourceId") String resourceId,
+            @HeaderParam(value = Constants.USER_ID_HEADER) String userId, @Context final HttpServletRequest request) {
+        return createOrUpdate(data, ComponentTypeEnum.RESOURCE, resourceId, request, userId, true);
+    }
+
+    @DELETE
+    @Consumes(MediaType.APPLICATION_JSON)
+    @Produces(MediaType.APPLICATION_JSON)
+    @Path("/resources/{resourceId}/interfaces/{interfaceId}/operations/{operationId}")
+    @ApiOperation(value = "Delete Interface Operation from Resource", httpMethod = "DELETE",
+            notes = "Delete Interface Operation from Resource", response = InterfaceDefinition.class, responseContainer = "List")
+    @ApiResponses(value = {@ApiResponse(code = 201, message = "Delete Interface Operation from Resource"),
+            @ApiResponse(code = 400, message = "Invalid content / Missing content"),
+            @ApiResponse(code = 403, message = "Restricted operation"),
+            @ApiResponse(code = 404, message = "Resource not found")})
+    public Response deleteInterfaceOperationsFromResource(
+            @ApiParam(value = "Resource Id") @PathParam("resourceId") String resourceId,
+            @ApiParam(value = "Interface Id") @PathParam("interfaceId") String interfaceId,
+            @ApiParam(value = "Operation Id") @PathParam("operationIds") String operationId,
+            @HeaderParam(value = Constants.USER_ID_HEADER) String userId, @Context final HttpServletRequest request) {
+        return delete(interfaceId, operationId, resourceId, request, userId);
+    }
 
-    ServletContext context = request.getSession().getServletContext();
-    String url = request.getMethod() + " " + request.getRequestURI();
+    private Response delete(String interfaceId, String operationIds, String componentId, HttpServletRequest request,
+            String userId) {
 
-    User modifier = new User();
-    modifier.setUserId(userId);
-    log.debug("Start delete request of {} with modifier id {}", url, userId);
+        ServletContext context = request.getSession().getServletContext();
+        String url = request.getMethod() + " " + request.getRequestURI();
 
-    try {
-      String componentIdLower = componentId.toLowerCase();
-      InterfaceOperationBusinessLogic businessLogic = getInterfaceOperationBL(context);
+        User modifier = new User();
+        modifier.setUserId(userId);
+        log.debug("Start delete request of {} with modifier id {}", url, userId);
 
-      Either<Operation, ResponseFormat> actionResponse = businessLogic.deleteInterfaceOperation(componentIdLower, interfaceOperationId, modifier, true);
-      if (actionResponse.isRight()) {
-        log.error("failed to delete interface operation");
-        return buildErrorResponse(actionResponse.right().value());
-      }
+        try {
+            String componentIdLower = componentId.toLowerCase();
+            InterfaceOperationBusinessLogic businessLogic = getInterfaceOperationBL(context);
 
-      InterfaceOperationDataDefinition interfaceOperationDataDefinition = InterfaceUIDataConverter.convertOperationDataToInterfaceData(actionResponse.left().value());
-      Object result = RepresentationUtils.toFilteredRepresentation(interfaceOperationDataDefinition);
-      return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), result);
+            List<String> operationsToDelete =
+                    Stream.of(operationIds.split(",")).map(String::trim).collect(Collectors.toList());
+            Either<List<InterfaceDefinition>, ResponseFormat> actionResponse = businessLogic.deleteInterfaceOperation(
+                    componentIdLower, interfaceId, operationsToDelete, modifier, true);
+            if (actionResponse.isRight()) {
+                log.error("failed to delete interface operation");
+                return buildErrorResponse(actionResponse.right().value());
+            }
+
+            return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK),
+                    getFormattedResponse(actionResponse.left().value()));
+        } catch (Exception e) {
+            BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Delete Interface Operation");
+            log.error("Delete interface operation with an error", e);
+            return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
+        }
     }
-    catch (Exception e) {
-      BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Delete Interface Operation");
-      log.error("Delete interface operation with an error", e);
-      return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
+
+    @GET
+    @Consumes(MediaType.APPLICATION_JSON)
+    @Produces(MediaType.APPLICATION_JSON)
+    @Path("/resources/{resourceId}/interfaces/{interfaceId}/operations/{operationId}")
+    @ApiOperation(value = "Get Interface Operation from Resource", httpMethod = "GET",
+            notes = "GET Interface Operation from Resource", response = InterfaceDefinition.class, responseContainer = "List")
+    @ApiResponses(value = {@ApiResponse(code = 201, message = "Delete Interface Operation from Resource"),
+            @ApiResponse(code = 400, message = "Invalid content / Missing content"),
+            @ApiResponse(code = 403, message = "Restricted operation"),
+            @ApiResponse(code = 404, message = "Resource not found")})
+    public Response getInterfaceOperationsFromResource(
+            @ApiParam(value = "Resource Id") @PathParam("resourceId") String resourceId,
+            @ApiParam(value = "Interface Id") @PathParam("interfaceId") String interfaceId,
+            @ApiParam(value = "Operation Id") @PathParam("operationId") String operationId,
+            @HeaderParam(value = Constants.USER_ID_HEADER) String userId, @Context final HttpServletRequest request) {
+        return get(interfaceId, operationId, resourceId, request, userId);
     }
-  }
-
-  private Response createOrUpdate (String data, String componentType, String componentId, HttpServletRequest request, String userId, boolean isUpdate) {
-    ServletContext context = request.getSession().getServletContext();
-    String url = request.getMethod() + " " + request.getRequestURI();
-
-    User modifier = new User();
-    modifier.setUserId(userId);
-    log.debug("Start create or update request of {} with modifier id {}", url, userId);
-
-    try {
-      String componentIdLower = componentId.toLowerCase();
-      InterfaceOperationBusinessLogic businessLogic = getInterfaceOperationBL(context);
-
-      Operation operation = getMappedOperationData(data, isUpdate, modifier, ComponentTypeEnum.findByParamName(componentType));
-      Either<Operation, ResponseFormat> actionResponse ;
-      if (isUpdate) {
-        actionResponse = businessLogic.updateInterfaceOperation(componentIdLower, operation, modifier, true);
-      } else {
-        actionResponse = businessLogic.createInterfaceOperation(componentIdLower, operation, modifier, true);
-      }
-
-      if (actionResponse.isRight()) {
-        log.error("failed to update or create interface operation");
-        return buildErrorResponse(actionResponse.right().value());
-      }
-
-      InterfaceOperationDataDefinition interfaceOperationDataDefinition = InterfaceUIDataConverter.convertOperationDataToInterfaceData(actionResponse.left().value());
-      Object result = RepresentationUtils.toFilteredRepresentation(interfaceOperationDataDefinition);
-      return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), result);
+
+    private Response get(String interfaceId, String operationIds, String componentId, HttpServletRequest request,
+            String userId) {
+        ServletContext context = request.getSession().getServletContext();
+        String url = request.getMethod() + " " + request.getRequestURI();
+
+        User modifier = new User();
+        modifier.setUserId(userId);
+        log.debug("Start get request of {} with modifier id {}", url, userId);
+
+        try {
+            String componentIdLower = componentId.toLowerCase();
+            InterfaceOperationBusinessLogic businessLogic = getInterfaceOperationBL(context);
+
+            List<String> operationsToGet =
+                    Stream.of(operationIds.split(",")).map(String::trim).collect(Collectors.toList());
+            Either<List<InterfaceDefinition>, ResponseFormat> actionResponse =
+                    businessLogic.getInterfaceOperation(componentIdLower, interfaceId, operationsToGet, modifier, true);
+            if (actionResponse.isRight()) {
+                log.error("failed to get interface operation");
+                return buildErrorResponse(actionResponse.right().value());
+            }
+
+            return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK),
+                    getFormattedResponse(actionResponse.left().value()));
+        } catch (Exception e) {
+            BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get Component interface operations");
+            log.error("get component interface operations failed with exception", e);
+            return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
+        }
     }
-    catch (Exception e) {
-      BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Interface Operation Creation or update");
-      log.error("create or update interface Operation with an error", e);
-      return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR));
+
+    @POST
+    @Consumes(MediaType.APPLICATION_JSON)
+    @Produces(MediaType.APPLICATION_JSON)
+    @Path("/services/{serviceId}/interfaceOperations")
+    @ApiOperation(value = "Create Interface Operations on Service", httpMethod = "POST",
+            notes = "Create Interface Operations on Service", response = InterfaceDefinition.class, responseContainer = "List")
+    @ApiResponses(value = {@ApiResponse(code = 201, message = "Create Interface Operations on Service"),
+            @ApiResponse(code = 400, message = "Invalid content / Missing content"),
+            @ApiResponse(code = 403, message = "Restricted operation"),
+            @ApiResponse(code = 404, message = "Service not found"),
+            @ApiResponse(code = 409, message = "Interface Operation already exist")})
+    public Response createInterfaceOperationsOnService(
+            @ApiParam(value = "Interface Operations to create", required = true) String data,
+            @ApiParam(value = "Service Id") @PathParam("serviceId") String serviceId,
+            @HeaderParam(value = Constants.USER_ID_HEADER) String userId, @Context final HttpServletRequest request) {
+        return createOrUpdate(data, ComponentTypeEnum.SERVICE, serviceId, request, userId, false);
+    }
+
+    @PUT
+    @Consumes(MediaType.APPLICATION_JSON)
+    @Produces(MediaType.APPLICATION_JSON)
+    @Path("/services/{serviceId}/interfaceOperations")
+    @ApiOperation(value = "Update Interface Operations on Service", httpMethod = "PUT",
+            notes = "Update Interface Operations on Service", response = InterfaceDefinition.class, responseContainer = "List")
+    @ApiResponses(value = {@ApiResponse(code = 201, message = "Update Interface Operations on Service"),
+            @ApiResponse(code = 400, message = "Invalid content / Missing content"),
+            @ApiResponse(code = 403, message = "Restricted operation"),
+            @ApiResponse(code = 404, message = "Service not found")})
+    public Response updateInterfaceOperationsOnService(
+            @ApiParam(value = "Interface Operations to update", required = true) String data,
+            @ApiParam(value = "Service Id") @PathParam("serviceId") String serviceId,
+            @HeaderParam(value = Constants.USER_ID_HEADER) String userId, @Context final HttpServletRequest request) {
+        return createOrUpdate(data, ComponentTypeEnum.SERVICE, serviceId, request, userId, true);
     }
-  }
-
-  private Operation getMappedOperationData(String inputJson, boolean isUpdate, User user, ComponentTypeEnum componentTypeEnum){
-    Either<UiComponentDataTransfer, ResponseFormat> uiComponentEither = getComponentsUtils().convertJsonToObjectUsingObjectMapper(inputJson, user, UiComponentDataTransfer.class, AuditingActionEnum.CREATE_RESOURCE, componentTypeEnum);
-    Optional<InterfaceOperationDataDefinition> opDef = uiComponentEither.left().value().getInterfaceOperations().values().stream().findFirst();
-    InterfaceOperationDataDefinition interfaceOperationDataDefinition = new InterfaceOperationDataDefinition();
-    if(opDef.isPresent()) {
-      interfaceOperationDataDefinition = opDef.get();
-      if(!isUpdate)
-        interfaceOperationDataDefinition.setUniqueId(UUID.randomUUID().toString());
+
+    @DELETE
+    @Consumes(MediaType.APPLICATION_JSON)
+    @Produces(MediaType.APPLICATION_JSON)
+    @Path("/services/{serviceId}/interfaces/{interfaceId}/operations/{operationId}")
+    @ApiOperation(value = "Delete Interface Operation from Service", httpMethod = "DELETE",
+            notes = "Delete Interface Operation from Service", response = InterfaceDefinition.class, responseContainer = "List")
+    @ApiResponses(value = {@ApiResponse(code = 201, message = "Delete Interface Operation from Service"),
+            @ApiResponse(code = 400, message = "Invalid content / Missing content"),
+            @ApiResponse(code = 403, message = "Restricted operation"),
+            @ApiResponse(code = 404, message = "Service not found")})
+    public Response deleteInterfaceOperationsFromService(
+            @ApiParam(value = "Service Id") @PathParam("serviceId") String serviceId,
+            @ApiParam(value = "Interface Id") @PathParam("interfaceId") String interfaceId,
+            @ApiParam(value = "Operation Id") @PathParam("operationId") String operationId,
+            @HeaderParam(value = Constants.USER_ID_HEADER) String userId, @Context final HttpServletRequest request) {
+        return delete(interfaceId, operationId, serviceId, request, userId);
+    }
+
+    @GET
+    @Consumes(MediaType.APPLICATION_JSON)
+    @Produces(MediaType.APPLICATION_JSON)
+    @Path("/services/{serviceId}/interfaces/{interfaceId}/operations/{operationId}")
+    @ApiOperation(value = "Get Interface Operation from Service", httpMethod = "GET",
+            notes = "GET Interface Operation from Service", response = InterfaceDefinition.class, responseContainer = "List")
+    @ApiResponses(value = {@ApiResponse(code = 201, message = "Get Interface Operation from Service"),
+            @ApiResponse(code = 400, message = "Invalid content / Missing content"),
+            @ApiResponse(code = 403, message = "Restricted operation"),
+            @ApiResponse(code = 404, message = "Service not found")})
+    public Response getInterfaceOperationsFromService(
+            @ApiParam(value = "Service Id") @PathParam("serviceId") String serviceId,
+            @ApiParam(value = "Interface Id") @PathParam("interfaceId") String interfaceId,
+            @ApiParam(value = "Operation Id") @PathParam("operationId") String operationId,
+            @HeaderParam(value = Constants.USER_ID_HEADER) String userId, @Context final HttpServletRequest request) {
+        return get(interfaceId, operationId, serviceId, request, userId);
     }
-    return InterfaceUIDataConverter.convertInterfaceDataToOperationData(interfaceOperationDataDefinition);
-  }
 
 }
 
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/RepresentationUtils.java b/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/RepresentationUtils.java
index dbdfaa9897..0358e67075 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/RepresentationUtils.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/RepresentationUtils.java
@@ -20,7 +20,6 @@
 
 package org.openecomp.sdc.be.servlets;
 
-
 import com.fasterxml.jackson.annotation.JsonFilter;
 import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.databind.DeserializationFeature;
@@ -32,20 +31,22 @@ import com.google.common.collect.ImmutableMap;
 import com.google.gson.Gson;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
 import org.openecomp.sdc.be.config.BeEcompErrorManager;
-import org.openecomp.sdc.be.datatypes.elements.InterfaceOperationDataDefinition;
 import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
 import org.openecomp.sdc.be.model.ArtifactDefinition;
 import org.openecomp.sdc.be.model.InterfaceDefinition;
-import org.openecomp.sdc.be.model.Operation;
 import org.openecomp.sdc.be.model.Resource;
 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
 import org.openecomp.sdc.common.api.Constants;
 import org.openecomp.sdc.common.log.wrappers.Logger;
 
-import java.io.IOException;
-import java.util.*;
-
 public class RepresentationUtils {
 
     private static final Logger log = Logger.getLogger(RepresentationUtils.class);
@@ -188,11 +189,8 @@ public class RepresentationUtils {
                     .put(ArrayList.class,IsEmptyFilterMixIn.class)
                     .put(HashSet.class,IsEmptyFilterMixIn.class)
                     .put(InterfaceDefinition.class,IsEmptyFilterMixIn.class)
-                    .put(Operation.class,IsEmptyFilterMixIn.class)
                     .put(Resource.class,IsEmptyFilterMixIn.class)
                     .put(ToscaDataDefinition.class,IsEmptyFilterMixIn.class)
-                    .put(InterfaceOperationDataDefinition.class,IsEmptyFilterMixIn.class).build();
-
-
+                    .build();
 
 }
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/ToscaExportHandler.java b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/ToscaExportHandler.java
index 69c4cec42b..6d344f78e5 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/ToscaExportHandler.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/ToscaExportHandler.java
@@ -45,6 +45,7 @@ import org.openecomp.sdc.be.model.ComponentParametersView;
 import org.openecomp.sdc.be.model.DataTypeDefinition;
 import org.openecomp.sdc.be.model.GroupInstance;
 import org.openecomp.sdc.be.model.InputDefinition;
+import org.openecomp.sdc.be.model.InterfaceDefinition;
 import org.openecomp.sdc.be.model.PropertyDefinition;
 import org.openecomp.sdc.be.model.RelationshipInfo;
 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
@@ -55,7 +56,9 @@ import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
 import org.openecomp.sdc.be.model.category.CategoryDefinition;
 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
 import org.openecomp.sdc.be.model.jsontitan.utils.ModelConverter;
+import org.openecomp.sdc.be.model.operations.api.IInterfaceLifecycleOperation;
 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
 import org.openecomp.sdc.be.tosca.model.SubstitutionMapping;
 import org.openecomp.sdc.be.tosca.model.ToscaCapability;
 import org.openecomp.sdc.be.tosca.model.ToscaGroupTemplate;
@@ -70,6 +73,7 @@ import org.openecomp.sdc.be.tosca.model.ToscaTopolgyTemplate;
 import org.openecomp.sdc.be.tosca.utils.ForwardingPathToscaUtil;
 import org.openecomp.sdc.be.tosca.utils.InputConverter;
 import org.openecomp.sdc.common.log.wrappers.Logger;
+import org.openecomp.sdc.exception.ResponseFormat;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.yaml.snakeyaml.DumperOptions;
 import org.yaml.snakeyaml.DumperOptions.FlowStyle;
@@ -112,11 +116,12 @@ public class ToscaExportHandler {
     private GroupExportParser groupExportParser;
     private PropertyConvertor propertyConvertor;
     private InputConverter inputConverter;
+    private InterfaceLifecycleOperation interfaceLifecycleOperation;
 
     @Autowired 
     public ToscaExportHandler(ApplicationDataTypeCache dataTypeCache, ToscaOperationFacade toscaOperationFacade,
                               CapabilityRequirementConverter capabilityRequirementConverter, PolicyExportParser policyExportParser,
-                              GroupExportParser groupExportParser, InputConverter inputConverter) {
+                              GroupExportParser groupExportParser, InputConverter inputConverter, InterfaceLifecycleOperation interfaceLifecycleOperation) {
             this.dataTypeCache = dataTypeCache;
             this.toscaOperationFacade = toscaOperationFacade;
             this.capabilityRequirementConverter = capabilityRequirementConverter;
@@ -124,6 +129,7 @@ public class ToscaExportHandler {
             this.groupExportParser = groupExportParser;
             this.propertyConvertor = PropertyConvertor.getInstance();
             this.inputConverter =  inputConverter;
+            this.interfaceLifecycleOperation = interfaceLifecycleOperation;
       }
 
 
@@ -553,7 +559,20 @@ public class ToscaExportHandler {
                                                                        boolean isAssociatedResourceComponent) {
         log.debug("start convert node type for {}", component.getUniqueId());
         ToscaNodeType toscaNodeType = createNodeType(component);
-        toscaNode.setInterface_types(addInterfaceTypeElement(component));
+
+        Either<Map<String, InterfaceDefinition>, StorageOperationStatus> lifecycleTypeEither =
+                interfaceLifecycleOperation.getAllInterfaceLifecycleTypes();
+        if(lifecycleTypeEither.isRight()){
+            log.debug("Failed to fetch all interface types :", lifecycleTypeEither.right().value());
+            return Either.right(ToscaError.GENERAL_ERROR);
+        }
+        List<String> allGlobalInterfaceTypes = lifecycleTypeEither.left().value()
+                                                       .values()
+                                                       .stream()
+                                                       .map(interfaceDef -> interfaceDef.getType())
+                                                       .collect(Collectors.toList());
+        toscaNode.setInterface_types(addInterfaceTypeElement(component, allGlobalInterfaceTypes));
+
         Either<Map<String, DataTypeDefinition>, TitanOperationStatus> dataTypesEither = dataTypeCache.getAll();
         if (dataTypesEither.isRight()) {
             log.debug("Failed to fetch all data types :", dataTypesEither.right().value());
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 7afad74f64..fbef11d2e8 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
@@ -60,7 +60,7 @@ public class InterfacesOperationsToscaUtil {
      * @param component to work on
      * @return the added element
      */
-    public static Map<String, Object> addInterfaceTypeElement(Component component) {
+    public static Map<String, Object> addInterfaceTypeElement(Component component, List<String> allInterfaceTypes) {
         if (component instanceof Product) {
             return null;
         }
@@ -68,24 +68,28 @@ public class InterfacesOperationsToscaUtil {
         if (MapUtils.isEmpty(interfaces)) {
             return null;
         }
+
         Map<String, Object> toscaInterfaceTypes = new HashMap<>();
         for (InterfaceDefinition interfaceDefinition : interfaces.values()) {
-            ToscaInterfaceNodeType toscaInterfaceType = new ToscaInterfaceNodeType();
-            toscaInterfaceType.setDerived_from(DERIVED_FROM_STANDARD_INTERFACE);
+            boolean isInterfaceTypeExistInGlobalType =
+                    allInterfaceTypes.stream().anyMatch(type -> type.equalsIgnoreCase(interfaceDefinition.getType()));
+            if (!isInterfaceTypeExistInGlobalType) {
+                ToscaInterfaceNodeType toscaInterfaceType = new ToscaInterfaceNodeType();
+                toscaInterfaceType.setDerived_from(DERIVED_FROM_STANDARD_INTERFACE);
 
-            final Map<String, OperationDataDefinition> operations = interfaceDefinition.getOperations();
-            Map<String, Object> toscaOperations = new HashMap<>();
+                final Map<String, OperationDataDefinition> operations = interfaceDefinition.getOperations();
+                Map<String, Object> toscaOperations = new HashMap<>();
 
-            for (Map.Entry<String, OperationDataDefinition> operationEntry : operations.entrySet()) {
-                toscaOperations.put(operationEntry.getValue().getName(),
-                        null); //currently not initializing any of the operations' fields as it is not needed
-            }
-            toscaInterfaceType.setOperations(toscaOperations);
-            Map<String, Object> interfacesAsMap = getObjectAsMap(toscaInterfaceType);
-            Map<String, Object> operationsMap = (Map<String, Object>) interfacesAsMap.remove(OPERATIONS_KEY);
-            interfacesAsMap.putAll(operationsMap);
+                for (Map.Entry<String, OperationDataDefinition> operationEntry : operations.entrySet()) {
+                    toscaOperations.put(operationEntry.getValue().getName(), null);
+                }
+                toscaInterfaceType.setOperations(toscaOperations);
+                Map<String, Object> interfacesAsMap = getObjectAsMap(toscaInterfaceType);
+                Map<String, Object> operationsMap = (Map<String, Object>) interfacesAsMap.remove(OPERATIONS_KEY);
+                interfacesAsMap.putAll(operationsMap);
 
-            toscaInterfaceTypes.put(interfaceDefinition.getToscaResourceName(), interfacesAsMap);
+                toscaInterfaceTypes.put(interfaceDefinition.getType(), interfacesAsMap);
+            }
         }
         return MapUtils.isNotEmpty(toscaInterfaceTypes) ? toscaInterfaceTypes : null;
     }
@@ -108,8 +112,8 @@ public class InterfacesOperationsToscaUtil {
         Map<String, Object> toscaInterfaceDefinitions = new HashMap<>();
         for (InterfaceDefinition interfaceDefinition : interfaces.values()) {
             ToscaInterfaceDefinition toscaInterfaceDefinition = new ToscaInterfaceDefinition();
-            final String toscaResourceName = interfaceDefinition.getToscaResourceName();
-            toscaInterfaceDefinition.setType(toscaResourceName);
+            final String interfaceType = interfaceDefinition.getType();
+            toscaInterfaceDefinition.setType(interfaceType);
             final Map<String, OperationDataDefinition> operations = interfaceDefinition.getOperations();
             Map<String, Object> toscaOperations = new HashMap<>();
 
@@ -133,7 +137,7 @@ public class InterfacesOperationsToscaUtil {
             Map<String, Object> operationsMap = (Map<String, Object>) interfaceDefAsMap.remove(OPERATIONS_KEY);
             handleDefaults(operationsMap);
             interfaceDefAsMap.putAll(operationsMap);
-            toscaInterfaceDefinitions.put(getLastPartOfName(toscaResourceName), interfaceDefAsMap);
+            toscaInterfaceDefinitions.put(getLastPartOfName(interfaceType), interfaceDefAsMap);
         }
         if (MapUtils.isNotEmpty(toscaInterfaceDefinitions)) {
             nodeType.setInterfaces(toscaInterfaceDefinitions);
@@ -141,8 +145,8 @@ public class InterfacesOperationsToscaUtil {
     }
 
     /***
-     * workaround for : currently "defaultp" is not being converted to "default" by the relevant code in ToscaExportHandler
-     * so, any string Map key named "defaultp" will have its named changed to "default"
+     * workaround for : currently "defaultp" is not being converted to "default" by the relevant code in
+     * ToscaExportHandler so, any string Map key named "defaultp" will have its named changed to "default"
      * @param operationsMap the map to update
      */
     private static void handleDefaults(Map<String, Object> operationsMap) {
diff --git a/catalog-be/src/main/resources/config/error-configuration.yaml b/catalog-be/src/main/resources/config/error-configuration.yaml
index 84213bbe8d..ff86aff820 100644
--- a/catalog-be/src/main/resources/config/error-configuration.yaml
+++ b/catalog-be/src/main/resources/config/error-configuration.yaml
@@ -2033,7 +2033,7 @@ errors:
 #---------SVC4695-----------------------------
 # %1 - Interface Operation Name
     INTERFACE_OPERATION_NAME_ALREADY_IN_USE: {
-      code: 400,
+      code: 409,
       message: "Error: Interface Operation name '%1' already in use, Your current changes will not be saved.",
       messageId: "SVC4695"
     }
@@ -2041,20 +2041,20 @@ errors:
 # %1 - Interface Operation Name
     INTERFACE_OPERATION_NAME_INVALID: {
       code: 400,
-      message: "Error: Interface Operation name '%1' is Invalid, Operation name should not contain special character, space, numbers and should not be greater than 200 characters.",
+      message: "Error: Interface Operation name '%1' is Invalid, Operation name should not contain special character, space and should not be greater than 200 characters.",
       messageId: "SVC4696"
     }
 #---------SVC4697-----------------------------
     INTERFACE_OPERATION_NAME_MANDATORY: {
-      code: 404,
+      code: 400,
       message: "Error: Interface Operation name is mandatory, Operation name can't be empty.",
       messageId: "SVC4697"
     }
 #---------SVC4698-----------------------------
-# %1 - Interface Operation description
-    INTERFACE_OPERATION_DESCRIPTION_MAX_LENGTH: {
+# %1 - Interface type
+    INTERFACE_OPERATION_INVALID_FOR_LOCAL_TYPE: {
       code: 400,
-      message: "Error: Interface Operation description '%1' is invalid, maximum 200 characters allowed.",
+      message: "Error: Invalid input, only one operation is allowed in local interface type '%1'.",
       messageId: "SVC4698"
     }
 #---------SVC4699-----------------------------
@@ -2066,20 +2066,20 @@ errors:
     }
 #---------SVC4700-----------------------------
     INTERFACE_OPERATION_INPUT_NAME_MANDATORY: {
-        code: 404,
+        code: 400,
         message: "Error: Interface operation input parameter name should not be empty.",
         messageId: "SVC4700"
     }
 #---------SVC4701-----------------------------
-# %1 - resource Id
+# %1 - component Id
     INTERFACE_OPERATION_NOT_FOUND: {
       code: 404,
-      message: "Error: Interface operation not found in the resource '%1'.",
+      message: "Error: Interface operation not found in the component '%1'.",
       messageId: "SVC4701"
     }
 #---------SVC4702-----------------------------
     INTERFACE_OPERATION_NOT_DELETED: {
-      code: 404,
+      code: 400,
       message: "Error: Failed to delete interface operation.",
       messageId: "SVC4702"
     }
@@ -2133,29 +2133,43 @@ errors:
       message: "Error: CSAR packaging failed for %1 %2.",
       messageId: "SVC4706"
     }
-#---------SVC4704-----------------------------
-# %1 - Interface Operation input property name
+#---------SVC4708-----------------------------
+# %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 component input properties.",
-        messageId: "SVC4704"
+        message: "Error: Interface operation input parameter property '%1' not found in '%2' input properties.",
+        messageId: "SVC4708"
     }
-#---------SVC4705-----------------------------
+#---------SVC4709-----------------------------
 # %1 - Interface Operation output parameter name
     INTERFACE_OPERATION_OUTPUT_NAME_ALREADY_IN_USE: {
         code: 400,
         message: "Error: Interface Operation output parameter name '%1' already in use, Your current changes will not be saved.",
-        messageId: "SVC4705"
+        messageId: "SVC4708"
     }
-#---------SVC4706-----------------------------
+#---------SVC4710-----------------------------
     INTERFACE_OPERATION_OUTPUT_NAME_MANDATORY: {
-        code: 404,
+        code: 400,
         message: "Error: Interface operation output parameter name should not be empty.",
-        messageId: "SVC4706"
+        messageId: "SVC4710"
+    }
+#---------SVC4711-----------------------------
+# %1 - interface Id
+    INTERFACE_NOT_FOUND_IN_COMPONENT: {
+      code: 404,
+      message: "Error: Interface not found in the component '%1'.",
+      messageId: "SVC4711"
     }
 #---------SVC4712-----------------------------
     INTERFACE_LIFECYCLE_TYPES_NOT_FOUND: {
         code: 404,
         message: "Error: Interface Lifecycle types not found.",
         messageId: "SVC4712"
+    }
+#---------SVC4713-----------------------------
+# %1 - Interface Operation Name
+    INTERFACE_OPERATION_INVALID_FOR_GLOBAL_TYPE: {
+        code: 400,
+        message: "Error: Invalid input, only pre-defined operation names are allowed in global interface type '%1'",
+        messageId: "SVC4713"
     }
\ No newline at end of file
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InputsBusinessLogicTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InputsBusinessLogicTest.java
index 1e6370e095..2ef3d463eb 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InputsBusinessLogicTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InputsBusinessLogicTest.java
@@ -67,9 +67,6 @@ public class InputsBusinessLogicTest {
     @Mock
     private ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
 
-    @Mock
-    private ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
-
     @InjectMocks
     private InputsBusinessLogic testInstance;
 
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 f2d8b57dbf..8509f3e749 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
@@ -18,432 +18,399 @@ package org.openecomp.sdc.be.components.impl;
 
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyBoolean;
-import static org.mockito.ArgumentMatchers.anyCollection;
+import static org.mockito.ArgumentMatchers.anyMap;
 import static org.mockito.ArgumentMatchers.anyObject;
 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.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-import javax.servlet.ServletContext;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
+import org.mockito.Mock;
 import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
-import org.openecomp.sdc.ElementOperationMock;
-import org.openecomp.sdc.be.auditing.impl.AuditingManager;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.openecomp.sdc.be.components.utils.ResourceBuilder;
 import org.openecomp.sdc.be.components.validation.InterfaceOperationValidation;
 import org.openecomp.sdc.be.components.validation.UserValidations;
-import org.openecomp.sdc.be.config.ConfigurationManager;
-import org.openecomp.sdc.be.dao.api.ActionStatus;
 import org.openecomp.sdc.be.dao.cassandra.ArtifactCassandraDao;
 import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus;
 import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
-import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
 import org.openecomp.sdc.be.impl.ComponentsUtils;
-import org.openecomp.sdc.be.impl.WebAppContextWrapper;
-import org.openecomp.sdc.be.model.Component;
-import org.openecomp.sdc.be.model.DataTypeDefinition;
+import org.openecomp.sdc.be.model.InputDefinition;
 import org.openecomp.sdc.be.model.InterfaceDefinition;
-import org.openecomp.sdc.be.model.LifecycleStateEnum;
-import org.openecomp.sdc.be.model.Operation;
 import org.openecomp.sdc.be.model.Resource;
 import org.openecomp.sdc.be.model.User;
-import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
 import org.openecomp.sdc.be.model.jsontitan.operations.InterfaceOperation;
-import org.openecomp.sdc.be.model.jsontitan.operations.NodeTemplateOperation;
-import org.openecomp.sdc.be.model.jsontitan.operations.NodeTypeOperation;
-import org.openecomp.sdc.be.model.jsontitan.operations.TopologyTemplateOperation;
 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
-import org.openecomp.sdc.be.model.operations.api.IElementOperation;
-import org.openecomp.sdc.be.model.operations.api.IPropertyOperation;
+import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
-import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation;
 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
-import org.openecomp.sdc.be.user.Role;
-import org.openecomp.sdc.be.user.UserBusinessLogic;
-import org.openecomp.sdc.common.api.ConfigurationSource;
-import org.openecomp.sdc.common.api.Constants;
-import org.openecomp.sdc.common.impl.ExternalConfiguration;
-import org.openecomp.sdc.common.impl.FSConfigurationSource;
 import org.openecomp.sdc.exception.ResponseFormat;
 import org.openecomp.sdc.test.utils.InterfaceOperationTestUtils;
-import org.springframework.web.context.WebApplicationContext;
 
+@RunWith(MockitoJUnitRunner.class)
 public class InterfaceOperationBusinessLogicTest {
 
-    private static final String RESOURCE_CATEGORY1 = "Network Layer 2-3";
-    private static final String RESOURCE_SUBCATEGORY = "Router";
-
-    private final String resourceId = "resourceId1";
-    private final String operationId = "uniqueId1";
-    private Operation operation;
-
+    private static final String resourceId = "resourceId";
+    private static final String interfaceId = "interfaceId";
+    private static final String operationId = "operationId";
+    private static final String inputId = "inputId";
     private static final String RESOURCE_NAME = "Resource1";
-
-    private final ServletContext servletContext = Mockito.mock(ServletContext.class);
-    private final TitanDao mockTitanDao = Mockito.mock(TitanDao.class);
-    private final UserBusinessLogic mockUserAdmin = Mockito.mock(UserBusinessLogic.class);
-    private final ToscaOperationFacade toscaOperationFacade = Mockito.mock(ToscaOperationFacade.class);
-    private final NodeTypeOperation nodeTypeOperation = Mockito.mock(NodeTypeOperation.class);
-    private final NodeTemplateOperation nodeTemplateOperation = Mockito.mock(NodeTemplateOperation.class);
-    private final TopologyTemplateOperation topologyTemplateOperation = Mockito.mock(TopologyTemplateOperation.class);
-    private final IPropertyOperation propertyOperation = Mockito.mock(IPropertyOperation.class);
-    private final ApplicationDataTypeCache applicationDataTypeCache = Mockito.mock(ApplicationDataTypeCache.class);
-    private final WebAppContextWrapper webAppContextWrapper = Mockito.mock(WebAppContextWrapper.class);
-    private final UserValidations userValidations = Mockito.mock(UserValidations.class);
-    private final WebApplicationContext webAppContext = Mockito.mock(WebApplicationContext.class);
-    private final ArtifactCassandraDao artifactCassandraDao = Mockito.mock(ArtifactCassandraDao.class);
-    private final InterfaceOperation interfaceOperation = Mockito.mock(InterfaceOperation.class);
-    private final InterfaceOperationValidation operationValidator = Mockito.mock(InterfaceOperationValidation.class);
-    private InterfaceLifecycleOperation interfaceLifecycleOperation = Mockito.mock(InterfaceLifecycleOperation.class);
-
-    private final GraphLockOperation graphLockOperation = Mockito.mock(GraphLockOperation.class);
-    private User user = null;
-    private final ArtifactsBusinessLogic artifactManager = new ArtifactsBusinessLogic();
-
+    private static final String operationId1 = "operationId1";
+    private static final String interfaceId1 = "interfaceId1";
     @InjectMocks
-    private
-    InterfaceOperationBusinessLogic bl = new InterfaceOperationBusinessLogic();
+    private InterfaceOperationBusinessLogic interfaceOperationBusinessLogic;
+    @Mock
+    private UserValidations userValidations;
+    @Mock
+    private ToscaOperationFacade toscaOperationFacade;
+    @Mock
+    private ComponentsUtils componentsUtils;
+    @Mock
+    private IGraphLockOperation graphLockOperation;
+    @Mock
+    private TitanDao titanDao;
+    @Mock
+    private InterfaceLifecycleOperation interfaceLifecycleOperation;
+    @Mock
+    private InterfaceOperationValidation interfaceOperationValidation;
+    @Mock
+    private InterfaceOperation interfaceOperation;
+    @Mock
+    private ArtifactCassandraDao artifactCassandraDao;
+    private User user;
+    private Resource resource;
 
     @Before
     public void setup() {
-        MockitoAnnotations.initMocks(this);
-        Mockito.reset(propertyOperation);
+        resource = new ResourceBuilder().setComponentType(ComponentTypeEnum.RESOURCE).setUniqueId(resourceId)
+                           .setName(RESOURCE_NAME).build();
+        resource.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinitionMap(interfaceId, operationId));
+        resource.setInputs(createInputsForResource());
 
-        ExternalConfiguration.setAppName("catalog-be");
-
-        // init Configuration
-        String appConfigDir = "src/test/resources/config/catalog-be";
-        ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir);
-        ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
-        ComponentsUtils componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class));
+        user = new User();
+        when(userValidations.validateUserExists(eq(user.getUserId()), anyString(), eq(true))).thenReturn(user);
+        when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
+        when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Resource)))
+                .thenReturn(StorageOperationStatus.OK);
+        when(interfaceOperationValidation
+                     .validateInterfaceOperations(anyObject(), anyObject(), any(), anyMap(), anyBoolean()))
+                .thenReturn(Either.left(true));
+        when(titanDao.commit()).thenReturn(TitanOperationStatus.OK);
+    }
 
-        // Elements
-        IElementOperation mockElementDao = new ElementOperationMock();
+    private List<InputDefinition> createInputsForResource() {
+        InputDefinition inputDefinition = new InputDefinition();
+        inputDefinition.setName(inputId);
+        inputDefinition.setInputId(inputId);
+        inputDefinition.setUniqueId(inputId);
+        inputDefinition.setValue(inputId);
+        inputDefinition.setDefaultValue(inputId);
+        return Arrays.asList(inputDefinition);
+    }
 
-        // User data and management
-        user = new User();
-        user.setUserId("jh0003");
-        user.setFirstName("Jimmi");
-        user.setLastName("Hendrix");
-        user.setRole(Role.ADMIN.name());
-
-        Either<User, ActionStatus> eitherGetUser = Either.left(user);
-        when(mockUserAdmin.getUser("jh0003", false)).thenReturn(eitherGetUser);
-        when(userValidations.validateUserExists(eq(user.getUserId()), anyString(), eq(false))).thenReturn(user);
-        when(userValidations.validateUserNotEmpty(eq(user), anyString())).thenReturn(user);
-        // Servlet Context attributes
-        when(servletContext.getAttribute(Constants.CONFIGURATION_MANAGER_ATTR)).thenReturn(configurationManager);
-        when(servletContext.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR)).thenReturn(webAppContextWrapper);
-        when(webAppContextWrapper.getWebAppContext(servletContext)).thenReturn(webAppContext);
-        when(webAppContext.getBean(IElementOperation.class)).thenReturn(mockElementDao);
-
-        Either<Boolean, StorageOperationStatus> eitherFalse = Either.left(true);
-        when(toscaOperationFacade.validateComponentNameExists("Root", ResourceTypeEnum.VFC, ComponentTypeEnum.RESOURCE)).thenReturn(eitherFalse);
-
-        Either<Boolean, StorageOperationStatus> eitherCountExist = Either.left(true);
-        when(toscaOperationFacade.validateComponentNameExists("alreadyExists", ResourceTypeEnum.VFC, ComponentTypeEnum.RESOURCE)).thenReturn(eitherCountExist);
-
-        Either<Boolean, StorageOperationStatus> eitherCount = Either.left(false);
-        when(toscaOperationFacade.validateComponentNameExists(eq(RESOURCE_NAME), any(ResourceTypeEnum.class), eq(ComponentTypeEnum.RESOURCE))).thenReturn(eitherCount);
-
-        Either<Boolean, StorageOperationStatus> validateDerivedExists = Either.left(true);
-        when(toscaOperationFacade.validateToscaResourceNameExists("Root")).thenReturn(validateDerivedExists);
-
-        Either<Boolean, StorageOperationStatus> validateDerivedNotExists = Either.left(false);
-        when(toscaOperationFacade.validateToscaResourceNameExists("kuku")).thenReturn(validateDerivedNotExists);
-        when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Resource))).thenReturn(StorageOperationStatus.OK);
-        when(graphLockOperation.lockComponentByName(Mockito.anyString(), eq(NodeTypeEnum.Resource))).thenReturn(StorageOperationStatus.OK);
-
-        // createResource
-        Resource resourceResponse = createResourceObject(true);
-        Either<Resource, StorageOperationStatus> eitherCreate = Either.left(resourceResponse);
-        when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(eitherCreate);
-        //TODO Remove if passes
-        /*when(toscaOperationFacade.validateCsarUuidUniqueness(Mockito.anyString())).thenReturn(eitherValidate);*/
-        Map<String, DataTypeDefinition> emptyDataTypes = new HashMap<>();
-        when(applicationDataTypeCache.getAll()).thenReturn(Either.left(emptyDataTypes));
-
-        //InterfaceOperation
-        when(operationValidator.validateInterfaceOperations(anyCollection(), anyObject(), anyBoolean())).thenReturn(Either.left(true));
-        when(mockTitanDao.commit()).thenReturn(TitanOperationStatus.OK);
-
-        // BL object
-        artifactManager.setNodeTemplateOperation(nodeTemplateOperation);
-        bl = new InterfaceOperationBusinessLogic();
-
-        bl.setUserAdmin(mockUserAdmin);
-        bl.setComponentsUtils(componentsUtils);
-        bl.setGraphLockOperation(graphLockOperation);
-        bl.setTitanGenericDao(mockTitanDao);
-        toscaOperationFacade.setNodeTypeOperation(nodeTypeOperation);
-        toscaOperationFacade.setTopologyTemplateOperation(topologyTemplateOperation);
-        bl.setToscaOperationFacade(toscaOperationFacade);
-        bl.setUserValidations(userValidations);
-        bl.setInterfaceOperation(interfaceOperation);
-        bl.setInterfaceOperationValidation(operationValidator);
-        bl.setInterfaceLifecycleOperation(interfaceLifecycleOperation);
-        Resource resourceCsar = createResourceObjectCsar(true);
-        setCanWorkOnResource(resourceCsar);
-        Either<Component, StorageOperationStatus> oldResourceRes = Either.left(resourceCsar);
-        when(toscaOperationFacade.getToscaFullElement(resourceCsar.getUniqueId())).thenReturn(oldResourceRes);
+    @Test
+    public void createInterfaceOperationTestOnExistingInterface() {
+        when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
+                .thenReturn(Either.left(Collections.emptyMap()));
+        when(interfaceOperation.updateInterfaces(any(), any())).thenReturn(Either.left(
+                Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId))));
+        Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither =
+                interfaceOperationBusinessLogic.createInterfaceOperation(resourceId,
+                        Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
+                                operationId)),
+                        user, true);
+        Assert.assertTrue(interfaceOperationEither.isLeft());
     }
 
     @Test
-    public void createInterfaceOperationTest() {
-        Resource resource = createResourceForInterfaceOperation();
-        resource.setComponentType(ComponentTypeEnum.RESOURCE);
-        validateUserRoles(Role.ADMIN, Role.DESIGNER);
-        when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
-        operation = InterfaceOperationTestUtils.createMockOperation();
-        when(interfaceOperation.addInterfaceOperation(any(), any(), any())).thenReturn(Either.left(InterfaceOperationTestUtils.mockOperationToReturn()));
+    public void createInterfaceOperationWithoutInterfaceTest() {
+        resource.getInterfaces().clear();
+        when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
+                .thenReturn(Either.left(Collections.emptyMap()));
+        when(interfaceOperation.addInterfaces(any(), any())).thenReturn(Either.left(
+                Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId))));
+        when(interfaceOperation.updateInterfaces(any(), any())).thenReturn(Either.left(
+                Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId))));
+        Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither =
+                interfaceOperationBusinessLogic.createInterfaceOperation(resourceId,
+                        Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
+                                operationId)),
+                        user, true);
+        Assert.assertTrue(interfaceOperationEither.isLeft());
+    }
 
-        Either<Operation, ResponseFormat> interfaceOperation = bl.createInterfaceOperation(resourceId, operation, user, true);
-        Assert.assertTrue(interfaceOperation.isLeft());
-        Assert.assertNotNull(interfaceOperation.left().value().getWorkflowId());
-        Assert.assertNotNull(interfaceOperation.left().value().getWorkflowVersionId());
+    @Test
+    public void createInterfaceOperationWithoutInterfaceTestFail() {
+        resource.getInterfaces().clear();
+        when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
+                .thenReturn(Either.left(Collections.emptyMap()));
+        when(interfaceOperation.addInterfaces(any(), any()))
+                .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
+        Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither =
+                interfaceOperationBusinessLogic.createInterfaceOperation(resourceId,
+                        Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
+                                operationId)),
+                        user, true);
+        Assert.assertTrue(interfaceOperationEither.isRight());
     }
 
     @Test
-    public void createInterfaceOperationWithoutInterfaceTest() {
-        Resource resource = createResourceObjectCsar(true);
-        resource.setComponentType(ComponentTypeEnum.RESOURCE);
-        resource.setInterfaces(new HashMap<>());
-        validateUserRoles(Role.ADMIN, Role.DESIGNER);
-        when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
-        operation = InterfaceOperationTestUtils.createMockOperation();
-        when(interfaceOperation.addInterfaceOperation(any(), any(), any())).thenReturn(Either.left(InterfaceOperationTestUtils.mockOperationToReturn()));
-        when(interfaceOperation.addInterface(anyString(), any())).thenReturn(Either.left(new InterfaceDefinition()));
+    public void shouldFailWhenCreateInterfaceOperationFailedTest() {
+        when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
+                .thenReturn(Either.left(Collections.emptyMap()));
+        when(interfaceOperation.updateInterfaces(any(), any()))
+                .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
+        Assert.assertTrue(interfaceOperationBusinessLogic.createInterfaceOperation(resourceId,
+                Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)),
+                user, true).isRight());
+    }
 
-        Either<Operation, ResponseFormat> interfaceOperation = bl.createInterfaceOperation(resourceId, operation, user, true);
+    @Test
+    public void updateInterfaceOperationTestWithArtifactSuccess() {
+        when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
+                .thenReturn(Either.left(Collections.emptyMap()));
+        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))));
+        Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperation =
+                interfaceOperationBusinessLogic.updateInterfaceOperation(resourceId,
+                        Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
+                                operationId)),
+                        user, true);
         Assert.assertTrue(interfaceOperation.isLeft());
+    }
 
+    @Test
+    public void updateInterfaceOperationTestWithArtifactFailure() {
+        when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
+                .thenReturn(Either.left(Collections.emptyMap()));
+        when(artifactCassandraDao.getCountOfArtifactById(any(String.class))).thenReturn(Either.left(new Long(1)));
+        when(artifactCassandraDao.deleteArtifact(any(String.class))).thenReturn(CassandraOperationStatus.GENERAL_ERROR);
+        Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperation =
+                interfaceOperationBusinessLogic.updateInterfaceOperation(resourceId,
+                        Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
+                                operationId)),
+                        user, true);
+        Assert.assertTrue(interfaceOperation.isRight());
     }
 
     @Test
-    public void shouldFailCreateInterfaceOperationWhenCreateOperationFailedTest() {
-        Resource resource = createResourceObjectCsar(true);
-        resource.setInterfaces(new HashMap<>());
-        validateUserRoles(Role.ADMIN, Role.DESIGNER);
-        when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
-        operation = InterfaceOperationTestUtils.createMockOperation();
-        when(interfaceOperation.addInterfaceOperation(any(), any(), any())).thenReturn(Either.left(InterfaceOperationTestUtils.mockOperationToReturn()));
-        when(interfaceOperation.addInterface(anyString(), any())).thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
+    public void updateInterfaceOperationTestWithoutArtifact() {
+        when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
+                .thenReturn(Either.left(Collections.emptyMap()));
+        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))));
+        Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperation =
+                interfaceOperationBusinessLogic.updateInterfaceOperation(resourceId,
+                        Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
+                                operationId)),
+                        user, true);
+        Assert.assertTrue(interfaceOperation.isLeft());
+    }
 
-        Either<Operation, ResponseFormat> interfaceOperation = bl.createInterfaceOperation(resourceId, operation, user, true);
+    @Test
+    public void updateInterfaceOperationTestDoesntExist() {
+        when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
+                .thenReturn(Either.left(Collections.emptyMap()));
+        Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperation =
+                interfaceOperationBusinessLogic.updateInterfaceOperation(resourceId,
+                        Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
+                                operationId)),
+                        user, true);
         Assert.assertTrue(interfaceOperation.isRight());
-
     }
 
-    @Test()
-    public void shouldFailWhenCreateInterfaceOperationFailedTest() {
-        Resource resource = createResourceForInterfaceOperation();
-        resource.setComponentType(ComponentTypeEnum.RESOURCE);
-        validateUserRoles(Role.ADMIN, Role.DESIGNER);
-        when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
-        operation = InterfaceOperationTestUtils.createMockOperation();
+    @Test
+    public void createInterfaceOperationTestFailOnException() {
+        when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
+                .thenReturn(Either.left(Collections.emptyMap()));
+        when(interfaceOperation.updateInterfaces(any(), any())).thenThrow(new RuntimeException());
+        Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither =
+                interfaceOperationBusinessLogic.createInterfaceOperation(resourceId,
+                        Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
+                                operationId)),
+                        user, true);
+        Assert.assertTrue(interfaceOperationEither.isRight());
+    }
 
-        when(interfaceOperation.addInterfaceOperation(any(), any(), any())).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
-       Assert.assertTrue(bl.createInterfaceOperation(resourceId, operation, user, true).isRight());
+    @Test
+    public void createInterfaceOperationTestFailOnFetchinGlobalTypes() {
+        when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
+                .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
+        Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither =
+                interfaceOperationBusinessLogic.createInterfaceOperation(resourceId,
+                        Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
+                                operationId)),
+                        user, true);
+        Assert.assertTrue(interfaceOperationEither.isRight());
     }
 
     @Test
-    public void updateInterfaceOperationTest() {
-        validateUserRoles(Role.ADMIN, Role.DESIGNER);
-        operation = InterfaceOperationTestUtils.createMockOperation();
-        Resource resource = createResourceForInterfaceOperation();
-        resource.setComponentType(ComponentTypeEnum.RESOURCE);
-        when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
-        when(interfaceOperation.updateInterfaceOperation(any(), any(), any())).thenReturn(Either.left(InterfaceOperationTestUtils.mockOperationToReturn()));
+    public void createInterfaceOperationTestFailOnValidation() {
+        when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
+                .thenReturn(Either.left(Collections.emptyMap()));
+        when(interfaceOperationValidation
+                     .validateInterfaceOperations(anyObject(), anyObject(), any(), anyMap(), anyBoolean()))
+                .thenReturn(Either.right(new ResponseFormat()));
+        Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither =
+                interfaceOperationBusinessLogic.createInterfaceOperation(resourceId,
+                        Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId,
+                                operationId)),
+                        user, true);
+        Assert.assertTrue(interfaceOperationEither.isRight());
+    }
 
-        Either<Operation, ResponseFormat> interfaceOperation = bl.updateInterfaceOperation(resourceId, operation, user, true);
-        Assert.assertTrue(interfaceOperation.isLeft());
+    @Test
+    public void deleteInterfaceOperationTestInterfaceDoesntExist() {
+        Assert.assertTrue(interfaceOperationBusinessLogic.deleteInterfaceOperation(resourceId, interfaceId1,
+                Collections.singletonList(operationId), user, true).isRight());
     }
 
-    @Test()
-    public void shouldFailWhenFailedToUpdateInterfaceOperationTest() {
-        validateUserRoles(Role.ADMIN, Role.DESIGNER);
-        operation = InterfaceOperationTestUtils.createMockOperation();
-        Resource resource = createResourceForInterfaceOperation();
-        resource.setComponentType(ComponentTypeEnum.RESOURCE);
-        when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
-        when(interfaceOperation.addInterfaceOperation(any(), any(), any())).thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
-        Either<Operation, ResponseFormat> interfaceOperation = bl.updateInterfaceOperation(resourceId, operation, user, true);
-        Assert.assertTrue(interfaceOperation.isRight());
+    @Test
+    public void deleteInterfaceOperationTestOperationDoesntExist() {
+        Assert.assertTrue(interfaceOperationBusinessLogic.deleteInterfaceOperation(resourceId, interfaceId,
+                Collections.singletonList(operationId1), user, true).isRight());
     }
 
     @Test
-    public void deleteInterfaceOperationTest() {
-        Resource resource = createResourceForInterfaceOperation();
-        resource.setComponentType(ComponentTypeEnum.RESOURCE);
-        validateUserRoles(Role.ADMIN, Role.DESIGNER);
-        when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
-        when(interfaceOperation.deleteInterfaceOperation(any(),any(), any())).thenReturn(Either.left(InterfaceOperationTestUtils.mockOperationToReturn()));
+    public void deleteInterfaceOperationTestSuccess() {
+        resource.getInterfaces().get(interfaceId).getOperations()
+                .putAll(InterfaceOperationTestUtils.createMockOperationMap(operationId1));
         when(artifactCassandraDao.deleteArtifact(any(String.class))).thenReturn(CassandraOperationStatus.OK);
-        Either<Operation, ResponseFormat> deleteResourceResponseFormatEither = bl.deleteInterfaceOperation(resourceId, operationId, user, true);
-        Assert.assertTrue(deleteResourceResponseFormatEither.isLeft());
+        when(interfaceOperation.updateInterfaces(any(), any())).thenReturn(Either.left(Collections.emptyList()));
+        Assert.assertTrue(interfaceOperationBusinessLogic.deleteInterfaceOperation(resourceId, interfaceId,
+                Collections.singletonList(operationId), user, true).isLeft());
     }
 
-    @Test()
+    @Test
     public void shouldFailWhenDeleteInterfaceOperationFailedTest() {
-        Resource resource = createResourceForInterfaceOperation();
-        resource.setComponentType(ComponentTypeEnum.RESOURCE);
-        validateUserRoles(Role.ADMIN, Role.DESIGNER);
-        when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
-        when(interfaceOperation.deleteInterfaceOperation(any(),any(), any())).thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
         when(artifactCassandraDao.deleteArtifact(any(String.class))).thenReturn(CassandraOperationStatus.OK);
-        Assert.assertTrue(bl.deleteInterfaceOperation(resourceId, operationId, user, true).isRight());
+        when(interfaceOperation.updateInterfaces(any(), any()))
+                .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
+        Assert.assertTrue(interfaceOperationBusinessLogic.deleteInterfaceOperation(resourceId, interfaceId,
+                Collections.singletonList(operationId), user, true).isRight());
+    }
 
+    @Test
+    public void deleteInterfaceOperationTestFailOnArtifactDeletion() {
+        when(artifactCassandraDao.deleteArtifact(any(String.class))).thenReturn(CassandraOperationStatus.GENERAL_ERROR);
+        Assert.assertTrue(interfaceOperationBusinessLogic.deleteInterfaceOperation(resourceId, interfaceId,
+                Collections.singletonList(operationId), user, true).isRight());
     }
+
     @Test
-    public void getInterfaceOperationTest() {
-        Resource resource = createResourceForInterfaceOperation();
-        resource.setComponentType(ComponentTypeEnum.RESOURCE);
-        validateUserRoles(Role.ADMIN, Role.DESIGNER);
-        when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource));
-        Either<Operation, ResponseFormat> getResourceResponseFormatEither = bl.getInterfaceOperation(resourceId, operationId, user, true);
-        Assert.assertTrue(getResourceResponseFormatEither.isLeft());
+    public void deleteInterfaceOperationTestFailOnException() {
+        when(artifactCassandraDao.deleteArtifact(any(String.class))).thenThrow(new RuntimeException());
+        Assert.assertTrue(interfaceOperationBusinessLogic.deleteInterfaceOperation(resourceId, interfaceId,
+                Collections.singletonList(operationId), user, true).isRight());
     }
 
     @Test
-    public void updateToscaResourceNameWhenComponentNameChanged() {
-        Component newComponent = new Resource();
-        newComponent.setName("newComponent");
-        Component  oldComponent  = createResourceForInterfaceOperation();
-        validateUserRoles(Role.ADMIN, Role.DESIGNER);
-        when(interfaceOperation.updateInterface(anyString(), any())).thenReturn(Either.left(InterfaceOperationTestUtils.mockInterfaceDefinitionToReturn(RESOURCE_NAME)));
-        Assert.assertTrue(bl.validateComponentNameAndUpdateInterfaces(oldComponent, newComponent).isLeft());
+    public void deleteInterfaceTestSuccess() {
+        when(artifactCassandraDao.deleteArtifact(any(String.class))).thenReturn(CassandraOperationStatus.OK);
+        when(interfaceOperation.updateInterfaces(any(), any())).thenReturn(Either.left(Collections.emptyList()));
+        when(interfaceOperation.deleteInterface(any(), any())).thenReturn(Either.left(interfaceId));
+        Assert.assertTrue(interfaceOperationBusinessLogic.deleteInterfaceOperation(resourceId, interfaceId,
+                Collections.singletonList(operationId), user, true).isLeft());
     }
 
     @Test
-    public void shouldFailWhenComponentNameChangedButUpdateOperationFailed() {
-        Component newComponent = new Resource();
-        newComponent.setName("newComponent");
-        Component  oldComponent  = createResourceForInterfaceOperation();
-        validateUserRoles(Role.ADMIN, Role.DESIGNER);
-        when(interfaceOperation.updateInterface(anyString(), anyObject())).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
-
-        Assert.assertTrue(bl.validateComponentNameAndUpdateInterfaces(oldComponent, newComponent).isRight());
+    public void deleteInterfaceTestFailure() {
+        when(artifactCassandraDao.deleteArtifact(any(String.class))).thenReturn(CassandraOperationStatus.OK);
+        when(interfaceOperation.updateInterfaces(any(), any())).thenReturn(Either.left(Collections.emptyList()));
+        when(interfaceOperation.deleteInterface(any(), any()))
+                .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
+        Assert.assertTrue(interfaceOperationBusinessLogic.deleteInterfaceOperation(resourceId, interfaceId,
+                Collections.singletonList(operationId), user, true).isRight());
     }
 
-    @Test(expected = Exception.class)
-    public void shouldThrowExceptionWhenComponentNameChangedButUpdateOperationFailed() {
-        Component newComponent = new Resource();
-        newComponent.setName("newComponent");
-        Component  oldComponent  = createResourceForInterfaceOperation();
-        validateUserRoles(Role.ADMIN, Role.DESIGNER);
-        when(interfaceOperation.updateInterface(anyString(), anyObject())).thenThrow(new Exception());
-        bl.validateComponentNameAndUpdateInterfaces(oldComponent, newComponent).isRight();
+    @Test
+    public void getInterfaceOperationTestInterfaceDoesntExist() {
+        Assert.assertTrue(interfaceOperationBusinessLogic.getInterfaceOperation(resourceId, interfaceId1,
+                Collections.singletonList(operationId), user, true).isRight());
     }
 
-    private void validateUserRoles(Role... roles) {
-        List<Role> listOfRoles = Stream.of(roles).collect(Collectors.toList());
+    @Test
+    public void getInterfaceOperationTestOperationDoesntExist() {
+        Assert.assertTrue(interfaceOperationBusinessLogic.getInterfaceOperation(resourceId, interfaceId,
+                Collections.singletonList(operationId1), user, true).isRight());
     }
 
-    private void setCanWorkOnResource(Resource resource) {
-        resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
-        resource.setLastUpdaterUserId(user.getUserId());
+    @Test
+    public void getInterfaceOperationTest() {
+        Assert.assertTrue(interfaceOperationBusinessLogic.getInterfaceOperation(resourceId, interfaceId,
+                Collections.singletonList(operationId), user, true).isLeft());
     }
 
-    private Resource createResourceForInterfaceOperation() {
-        Resource resource = new Resource();
-        resource.setUniqueId(resourceId);
-        resource.setName(RESOURCE_NAME);
-        resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
-        resource.setDescription("Resource name for response");
-        resource.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinition(RESOURCE_NAME));
-        return resource;
+    @Test
+    public void getInterfaceOperationTestFailOnException() {
+        when(titanDao.commit()).thenThrow(new RuntimeException());
+        Assert.assertTrue(interfaceOperationBusinessLogic.getInterfaceOperation(resourceId, interfaceId,
+                Collections.singletonList(operationId), user, true).isRight());
     }
 
-    private Resource createResourceObjectCsar(boolean afterCreate) {
-        Resource resource = new Resource();
-        resource.setName(RESOURCE_NAME);
-        resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
-        resource.setDescription("My short description");
-        List<String> tgs = new ArrayList<>();
-        tgs.add("test");
-        tgs.add(resource.getName());
-        resource.setTags(tgs);
-        List<String> template = new ArrayList<>();
-        template.add("Root");
-        resource.setDerivedFrom(template);
-        resource.setVendorName("Motorola");
-        resource.setVendorRelease("1.0.0");
-        resource.setResourceVendorModelNumber("");
-        resource.setContactId("ya5467");
-        resource.setIcon("MyIcon");
-        resource.setCsarUUID("valid_vf.csar");
-        resource.setCsarVersion("1");
-
-        if (afterCreate) {
-            resource.setName(resource.getName());
-            resource.setVersion("0.1");
-            resource.setUniqueId(resource.getName().toLowerCase() + ":" + resource.getVersion());
-            resource.setCreatorUserId(user.getUserId());
-            resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
-            resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
-        }
-        return resource;
+    @Test
+    public void shouldFailWhenLockComponentFailedTest() {
+        when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Resource)))
+                .thenReturn(StorageOperationStatus.NOT_FOUND);
+        Assert.assertTrue(interfaceOperationBusinessLogic.deleteInterfaceOperation(resourceId, interfaceId,
+                Collections.singletonList(operationId), user, true).isRight());
+        Assert.assertTrue(interfaceOperationBusinessLogic.getInterfaceOperation(resourceId, interfaceId,
+                Collections.singletonList(operationId), user, true).isRight());
+        Assert.assertTrue(interfaceOperationBusinessLogic.createInterfaceOperation(resourceId,
+                Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)),
+                user, true).isRight());
     }
 
-    private Resource createResourceObject(boolean afterCreate) {
-        Resource resource = new Resource();
-        resource.setName(RESOURCE_NAME);
-        resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
-        resource.setDescription("My short description");
-        List<String> tgs = new ArrayList<>();
-        tgs.add("test");
-        tgs.add(resource.getName());
-        resource.setTags(tgs);
-        List<String> template = new ArrayList<>();
-        template.add("Root");
-        resource.setDerivedFrom(template);
-        resource.setVendorName("Motorola");
-        resource.setVendorRelease("1.0.0");
-        resource.setContactId("ya5467");
-        resource.setIcon("MyIcon");
-
-        if (afterCreate) {
-            resource.setName(resource.getName());
-            resource.setVersion("0.1");
-            resource.setUniqueId(resource.getName().toLowerCase() + ":" + resource.getVersion());
-            resource.setCreatorUserId(user.getUserId());
-            resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
-            resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
-        }
-        return resource;
+    @Test
+    public void shouldFailWhenGetComponentFailedTest() {
+        when(toscaOperationFacade.getToscaElement(resourceId))
+                .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
+        Assert.assertTrue(interfaceOperationBusinessLogic.deleteInterfaceOperation(resourceId, interfaceId,
+                Collections.singletonList(operationId), user, true).isRight());
+        Assert.assertTrue(interfaceOperationBusinessLogic.getInterfaceOperation(resourceId, interfaceId,
+                Collections.singletonList(operationId), user, true).isRight());
+        Assert.assertTrue(interfaceOperationBusinessLogic.createInterfaceOperation(resourceId,
+                Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)),
+                user, true).isRight());
     }
 
     @Test
     public void testGetAllInterfaceLifecycleTypes_TypesNotFound() {
-        when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
-        Either<Map<String, InterfaceDefinition>, ResponseFormat> response = bl.getAllInterfaceLifecycleTypes();
+        when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
+                .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
+        Either<Map<String, InterfaceDefinition>, ResponseFormat> response =
+                interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes();
         Assert.assertTrue(response.isRight());
     }
 
     @Test
     public void testGetAllInterfaceLifecycleTypes_Success() {
-        final String UNIQUE_ID = "UNIQUE_ID";
-        final String TYPE = "UNIQUE_ID";
         InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
-        interfaceDefinition.setUniqueId(UNIQUE_ID);
-        interfaceDefinition.setType(TYPE);
+        interfaceDefinition.setUniqueId(interfaceId);
+        interfaceDefinition.setType(interfaceId);
         Map<String, InterfaceDefinition> interfaceDefinitionMap = new HashMap<>();
         interfaceDefinitionMap.put(interfaceDefinition.getUniqueId(), interfaceDefinition);
-        when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(interfaceDefinitionMap));
-        Either<Map<String, InterfaceDefinition>, ResponseFormat>  response = bl.getAllInterfaceLifecycleTypes();
-        Assert.assertEquals(response.left().value().size(),1);
+        when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
+                .thenReturn(Either.left(interfaceDefinitionMap));
+        Either<Map<String, InterfaceDefinition>, ResponseFormat> response =
+                interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes();
+        Assert.assertEquals(1, response.left().value().size());
     }
 }
\ No newline at end of file
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogicTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogicTest.java
index b6a7c98efa..8e35981722 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogicTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogicTest.java
@@ -32,7 +32,6 @@ import org.openecomp.sdc.ElementOperationMock;
 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
 import org.openecomp.sdc.be.datamodel.api.HighestFilterEnum;
 import org.openecomp.sdc.be.model.operations.StorageException;
-import org.openecomp.sdc.test.utils.InterfaceOperationTestUtils;
 import org.openecomp.sdc.be.components.csar.CsarBusinessLogic;
 import org.openecomp.sdc.be.components.csar.CsarInfo;
 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
@@ -60,7 +59,6 @@ import org.openecomp.sdc.be.model.PropertyDefinition;
 import org.openecomp.sdc.be.model.Resource;
 import org.openecomp.sdc.be.model.User;
 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
-import org.openecomp.sdc.be.model.jsontitan.operations.InterfaceOperation;
 import org.openecomp.sdc.be.model.jsontitan.operations.NodeTemplateOperation;
 import org.openecomp.sdc.be.model.jsontitan.operations.NodeTypeOperation;
 import org.openecomp.sdc.be.model.jsontitan.operations.TopologyTemplateOperation;
@@ -156,8 +154,6 @@ public class ResourceBusinessLogicTest {
     UserValidations userValidations = Mockito.mock(UserValidations.class);
     WebApplicationContext webAppContext = Mockito.mock(WebApplicationContext.class);
     IInterfaceLifecycleOperation interfaceTypeOperation = Mockito.mock(IInterfaceLifecycleOperation.class);
-    InterfaceOperation interfaceOperation = Mockito.mock(InterfaceOperation.class);
-    InterfaceOperationBusinessLogic interfaceOperationBl = Mockito.mock(InterfaceOperationBusinessLogic.class);
 
     @InjectMocks
     ResourceBusinessLogic bl = new ResourceBusinessLogic();
@@ -228,7 +224,6 @@ public class ResourceBusinessLogicTest {
         /*when(toscaOperationFacade.validateComponentNameExists(RESOURCE_NAME, ResourceTypeEnum.VF, ComponentTypeEnum.RESOURCE)).thenReturn(eitherCount);
         when(toscaOperationFacade.validateComponentNameExists(RESOURCE_NAME, ResourceTypeEnum.PNF, ComponentTypeEnum.RESOURCE)).thenReturn(eitherCount);
         when(toscaOperationFacade.validateComponentNameExists(RESOURCE_NAME, ResourceTypeEnum.CR, ComponentTypeEnum.RESOURCE)).thenReturn(eitherCount);*/
-        when(interfaceOperation.updateInterface(anyString(), anyObject())).thenReturn(Either.left(InterfaceOperationTestUtils.mockInterfaceDefinitionToReturn(RESOURCE_NAME)));
         Either<Boolean, StorageOperationStatus> validateDerivedExists = Either.left(true);
         when(toscaOperationFacade.validateToscaResourceNameExists("Root")).thenReturn(validateDerivedExists);
 
@@ -245,7 +240,6 @@ public class ResourceBusinessLogicTest {
         Map<String, DataTypeDefinition> emptyDataTypes = new HashMap<>();
         when(applicationDataTypeCache.getAll()).thenReturn(Either.left(emptyDataTypes));
         when(mockTitanDao.commit()).thenReturn(TitanOperationStatus.OK);
-        when(interfaceOperationBl.validateComponentNameAndUpdateInterfaces(any(Component.class), any(Component.class))).thenReturn(Either.left(true));
 
         // BL object
         artifactManager.setNodeTemplateOperation(nodeTemplateOperation);
@@ -267,8 +261,6 @@ public class ResourceBusinessLogicTest {
         bl.setToscaOperationFacade(toscaOperationFacade);
         bl.setUserValidations(userValidations);
         bl.setInterfaceTypeOperation(interfaceTypeOperation);
-        bl.setInterfaceOperation(interfaceOperation);
-        bl.setInterfaceOperationBusinessLogic(interfaceOperationBl);
 
         csarBusinessLogic.setCsarOperation(csarOperation);
         Resource resourceCsar = createResourceObjectCsar(true);
@@ -950,7 +942,6 @@ public class ResourceBusinessLogicTest {
     @Test
     public void testResourceNameWrongFormat_UPDATE() {
         Resource resource = createResourceObject(true);
-        resource.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinition(RESOURCE_NAME));
         Resource updatedResource = createResourceObject(true);
 
         // this is in order to prevent failing with 403 earlier
@@ -972,7 +963,6 @@ public class ResourceBusinessLogicTest {
     @Test
     public void testResourceNameAfterCertify_UPDATE() {
         Resource resource = createResourceObject(true);
-        resource.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinition(RESOURCE_NAME));
         Resource updatedResource = createResourceObject(true);
 
         // this is in order to prevent failing with 403 earlier
@@ -996,7 +986,6 @@ public class ResourceBusinessLogicTest {
     @Test
     public void testResourceNameAlreadyExist_UPDATE() {
         Resource resource = createResourceObject(true);
-        resource.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinition(RESOURCE_NAME));
         Resource updatedResource = createResourceObject(true);
 
         // this is in order to prevent failing with 403 earlier
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
new file mode 100644
index 0000000000..59f95ba8da
--- /dev/null
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/utils/InterfaceOperationUtilsTest.java
@@ -0,0 +1,95 @@
+package org.openecomp.sdc.be.components.utils;
+
+import java.util.Map;
+import java.util.Optional;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
+import org.openecomp.sdc.be.model.InterfaceDefinition;
+import org.openecomp.sdc.be.model.Operation;
+import org.openecomp.sdc.be.model.Resource;
+import org.openecomp.sdc.test.utils.InterfaceOperationTestUtils;
+
+public class InterfaceOperationUtilsTest {
+
+    private static final String TEST_RESOURCE_NAME = "TestResource";
+    private static final String operationId = "operationId";
+    private static final String interfaceId = "interfaceId";
+    private static Resource resource;
+
+    @Before
+    public void setup() {
+        resource =
+                new ResourceBuilder().setComponentType(ComponentTypeEnum.RESOURCE).setName(TEST_RESOURCE_NAME).build();
+        resource.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinitionMap(interfaceId, operationId));
+    }
+
+    @Test
+    public void testGetInterfaceDefinitionFromComponentByInterfaceTypeSuccess() {
+        Assert.assertTrue(
+                InterfaceOperationUtils.getInterfaceDefinitionFromComponentByInterfaceType(resource, interfaceId)
+                        .isPresent());
+    }
+
+    @Test
+    public void testGetInterfaceDefinitionFromComponentByInterfaceTypeFailure() {
+        Assert.assertFalse(
+                InterfaceOperationUtils.getInterfaceDefinitionFromComponentByInterfaceType(resource, TEST_RESOURCE_NAME)
+                        .isPresent());
+    }
+
+    @Test
+    public void testGetInterfaceDefinitionFromComponentByInterfaceTypeNoInterface() {
+        resource.getInterfaces().clear();
+        Assert.assertFalse(
+                InterfaceOperationUtils.getInterfaceDefinitionFromComponentByInterfaceType(resource, interfaceId)
+                        .isPresent());
+    }
+
+    @Test
+    public void testGetInterfaceDefinitionFromComponentByInterfaceIdSuccess() {
+        Assert.assertTrue(
+                InterfaceOperationUtils.getInterfaceDefinitionFromComponentByInterfaceId(resource, interfaceId)
+                        .isPresent());
+    }
+
+    @Test
+    public void testGetInterfaceDefinitionFromComponentByInterfaceIdFailure() {
+        Assert.assertFalse(
+                InterfaceOperationUtils.getInterfaceDefinitionFromComponentByInterfaceId(resource, TEST_RESOURCE_NAME)
+                        .isPresent());
+    }
+
+    @Test
+    public void testGetInterfaceDefinitionFromComponentByInterfaceIdNoInterface() {
+        resource.getInterfaces().clear();
+        Assert.assertFalse(
+                InterfaceOperationUtils.getInterfaceDefinitionFromComponentByInterfaceId(resource, interfaceId)
+                        .isPresent());
+    }
+
+    @Test
+    public void testGetOperationFromInterfaceDefinitionSuccess() {
+        Assert.assertTrue(InterfaceOperationUtils.getOperationFromInterfaceDefinition(
+                InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId), operationId).isPresent());
+    }
+
+    @Test
+    public void testGetOperationFromInterfaceDefinitionFailure() {
+        Assert.assertFalse(InterfaceOperationUtils.getOperationFromInterfaceDefinition(
+                InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId), TEST_RESOURCE_NAME)
+                                   .isPresent());
+    }
+
+    @Test
+    public void testGetOperationFromInterfaceDefinitionNoOperationMap() {
+        InterfaceDefinition interfaceDefinition =
+                InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId);
+        interfaceDefinition.getOperations().clear();
+        Optional<Map.Entry<String, Operation>> operationEntry =
+                InterfaceOperationUtils.getOperationFromInterfaceDefinition(interfaceDefinition, TEST_RESOURCE_NAME);
+        Assert.assertFalse(operationEntry.isPresent());
+    }
+
+}
\ No newline at end of file
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 1a112c583b..fc1b03ed78 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
@@ -19,264 +19,344 @@ package org.openecomp.sdc.be.components.validation;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.when;
 
-import com.google.common.collect.Sets;
-import fj.data.Either;
-
-import java.util.ArrayList;
-import java.util.Collection;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.Mockito;
 import org.mockito.MockitoAnnotations;
 import org.openecomp.sdc.be.components.impl.ResponseFormatManager;
+import org.openecomp.sdc.be.components.utils.ResourceBuilder;
 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
 import org.openecomp.sdc.be.datatypes.elements.OperationOutputDefinition;
+import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
 import org.openecomp.sdc.be.model.ArtifactDefinition;
-import org.openecomp.sdc.be.model.ComponentInstanceInput;
+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;
-import org.openecomp.sdc.be.model.Component;
-import org.openecomp.sdc.be.model.Resource;
 import org.openecomp.sdc.exception.ResponseFormat;
 import org.openecomp.sdc.test.utils.InterfaceOperationTestUtils;
 
 public class InterfaceOperationValidationTest {
 
-    private final Component component = setUpComponentMock();
+    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 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;
 
-    private final InterfaceOperationValidationUtilTest interfaceOperationValidationUtilTest = new InterfaceOperationValidationUtilTest();
-    private final ListDataDefinition<OperationInputDefinition> operationInputDefinitionList = new ListDataDefinition<>();
-    private final ListDataDefinition<OperationOutputDefinition> operationOutputDefinitionList = new ListDataDefinition<>();
-
     @Before
-    public void init() {
+    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.setInputs(createInputsForComponent());
     }
 
-    @Test
-    public void shouldPassOperationValidationForHappyScenario() {
-        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label1"));
-        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("label1"));
-        Collection<Operation> operations = createInterfaceOperationData("op2",
-                "interface operation2",new ArtifactDefinition(), operationInputDefinitionList,
-                        operationOutputDefinitionList,"upgrade");
-        Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest
-                .validateInterfaceOperations(operations, component, false);
-        Assert.assertTrue(booleanResponseFormatEither.isLeft());
+    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 shouldFailWhenOperationOperationDescriptionLengthInvalid() {
-        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label1"));
-        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("label1"));
-        Collection<Operation> operations = createInterfaceOperationData("op2",
-                "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",
-                new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList,"update");
-        Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest
-                .validateInterfaceOperations(operations, component, false);
-        Assert.assertTrue(booleanResponseFormatEither.isRight());
+    public void shouldPassOperationValidationForHappyScenario() {
+        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
+        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
+        InterfaceDefinition interfaceDefinition =
+                createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
+                        operationInputDefinitionList, operationOutputDefinitionList, "upgrade");
+        Assert.assertTrue(interfaceOperationValidationUtilTest
+                                  .validateInterfaceOperations(interfaceDefinition, component,
+                                          component.getInterfaces().get(interfaceId), 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("label1"));
-        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("label1"));
-        Collection<Operation> operations = createInterfaceOperationData("op2",
-                "interface operation2",new ArtifactDefinition(), operationInputDefinitionList,
-                operationOutputDefinitionList, "");
-        Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest
-                .validateInterfaceOperations(operations, component, false);
-        Assert.assertTrue(booleanResponseFormatEither.isRight());
+        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
+        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
+        InterfaceDefinition interfaceDefinition =
+                createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
+                        operationInputDefinitionList, operationOutputDefinitionList, "");
+        Assert.assertTrue(interfaceOperationValidationUtilTest
+                                  .validateInterfaceOperations(interfaceDefinition, component,
+                                          component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
+                                  .isRight());
     }
 
     @Test
-    public void shouldFailWhenOperationNamesAreNotUnique() {
-        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label1"));
-        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("label1"));
-        Collection<Operation> operations = createInterfaceOperationData("op2",
-                "interface operation2",new ArtifactDefinition(), operationInputDefinitionList,
-                operationOutputDefinitionList,"CREATE");
-        Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest
-                .validateInterfaceOperations(operations, component, false);
-        Assert.assertTrue(booleanResponseFormatEither.isRight());
+    public void shouldFailWhenOperationNamesAreNotUniqueForCreate() {
+        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
+        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
+        InterfaceDefinition interfaceDefinition =
+                createInterfaceOperationData(operationId, operationId2, new ArtifactDefinition(),
+                        operationInputDefinitionList, operationOutputDefinitionList, operationId);
+        Assert.assertTrue(interfaceOperationValidationUtilTest
+                                  .validateInterfaceOperations(interfaceDefinition, component,
+                                          component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
+                                  .isRight());
     }
 
     @Test
-    public void shouldFailWhenOperationNameLengthIsInvalid() {
-        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label1"));
-        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("label1"));
-        Collection<Operation> operations = createInterfaceOperationData("op2",
-                "interface operation2",new ArtifactDefinition(), 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");
-        Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest
-                .validateInterfaceOperations(operations, component, false);
-        Assert.assertTrue(booleanResponseFormatEither.isRight());
+    public void shouldNotFailWhenOperationNamesAreNotUniqueForUpdate() {
+        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
+        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
+        InterfaceDefinition interfaceDefinition =
+                createInterfaceOperationData(operationId, operationId2, new ArtifactDefinition(),
+                        operationInputDefinitionList, operationOutputDefinitionList, operationId);
+        Assert.assertTrue(interfaceOperationValidationUtilTest
+                                  .validateInterfaceOperations(interfaceDefinition, component,
+                                          component.getInterfaces().get(interfaceId), Collections.emptyMap(), true)
+                                  .isLeft());
     }
 
+    @Test
+    public void shouldFailWhenOperationNameLengthIsInvalid() {
+        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
+        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
+        InterfaceDefinition interfaceDefinition =
+                createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
+                        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");
+        Assert.assertTrue(interfaceOperationValidationUtilTest
+                                  .validateInterfaceOperations(interfaceDefinition, component,
+                                          component.getInterfaces()
+                                                  .get(interfaceId), Collections.emptyMap(), false)
+                                  .isRight());
+    }
 
     @Test
     public void shouldFailWhenOperationInputParamNamesAreNotUnique() {
-        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label1"));
-        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label1"));
-        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label2"));
-        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label2"));
-        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("label1"));
-        Collection<Operation> operations = createInterfaceOperationData("op2",
-                "interface operation2",new ArtifactDefinition(), operationInputDefinitionList,
-                operationOutputDefinitionList,"create");
-
-        Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest
-                .validateInterfaceOperations(operations, component, false);
-        Assert.assertTrue(booleanResponseFormatEither.isRight());
+        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
+        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
+        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(outputId));
+        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
+        InterfaceDefinition interfaceDefinition =
+                createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
+                        operationInputDefinitionList, operationOutputDefinitionList, "create");
+        Assert.assertTrue(interfaceOperationValidationUtilTest
+                                  .validateInterfaceOperations(interfaceDefinition, component,
+                                          component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
+                                  .isRight());
     }
 
     @Test
     public void shouldPassWhenOperationInputParamNamesAreUnique() {
-        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label1"));
-        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label2"));
-        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("label1"));
-        Collection<Operation> operations = createInterfaceOperationData("op2",
-                "interface operation2",new ArtifactDefinition(), operationInputDefinitionList,
-                operationOutputDefinitionList,"update");
-
-        Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest
-                .validateInterfaceOperations(operations, component, false);
-        Assert.assertTrue(booleanResponseFormatEither.isLeft());
+        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
+        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(outputId));
+        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
+        InterfaceDefinition interfaceDefinition =
+                createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
+                        operationInputDefinitionList, operationOutputDefinitionList, "update");
+        Assert.assertTrue(interfaceOperationValidationUtilTest
+                                  .validateInterfaceOperations(interfaceDefinition, component,
+                                          component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
+                                  .isLeft());
     }
 
     @Test
     public void shouldPassWhenOperationInputParamNamesHasSubProperty() {
-        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label1"));
-        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label2"));
-        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("label1"));
-        Collection<Operation> operations = createInterfaceOperationData("op2",
-                "interface operation2",new ArtifactDefinition(), operationInputDefinitionList,
-                operationOutputDefinitionList,"update");
-        operationInputDefinitionList.getListToscaDataDefinition().get(0).setInputId(operationInputDefinitionList
-                .getListToscaDataDefinition().get(0).getInputId().concat(".subproperty"));
-        Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest
-                .validateInterfaceOperations(operations, component, false);
-        Assert.assertTrue(booleanResponseFormatEither.isLeft());
+        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
+        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
+        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());
     }
 
     @Test
     public void shouldFailWhenOperationInputParamNameEmpty() {
         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("  "));
-        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label1"));
-        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("label1"));
-        Collection<Operation> operations = createInterfaceOperationData("op2",
-                "interface operation2",new ArtifactDefinition(), operationInputDefinitionList,
-                operationOutputDefinitionList,"update");
-
-        Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest
-                .validateInterfaceOperations(operations, component, false);
-        Assert.assertTrue(booleanResponseFormatEither.isRight());
+        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
+        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
+        InterfaceDefinition interfaceDefinition =
+                createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
+                        operationInputDefinitionList, operationOutputDefinitionList, "update");
+        Assert.assertTrue(interfaceOperationValidationUtilTest
+                                  .validateInterfaceOperations(interfaceDefinition, component,
+                                          component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
+                                  .isRight());
     }
 
     @Test
     public void shouldFailWhenOperationOutputParamNameEmpty() {
-        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("inputParam"));
-        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label1"));
+        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(" "));
-        Collection<Operation> operations = createInterfaceOperationData("op2",
-                "interface operation2",new ArtifactDefinition(), operationInputDefinitionList,
-                operationOutputDefinitionList,"update");
-
-        Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest
-                .validateInterfaceOperations(operations, component, false);
-        Assert.assertTrue(booleanResponseFormatEither.isRight());
+        InterfaceDefinition interfaceDefinition =
+                createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
+                        operationInputDefinitionList, operationOutputDefinitionList, "update");
+        Assert.assertTrue(interfaceOperationValidationUtilTest
+                                  .validateInterfaceOperations(interfaceDefinition, component,
+                                          component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
+                                  .isRight());
     }
 
     @Test
     public void shouldPassWhenInterfaceOperationOutputParamNamesUnique() {
-        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label1"));
-        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("label1"));
-        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("label2"));
-        Collection<Operation> operations = createInterfaceOperationData("op2",
-                "interface operation2",new ArtifactDefinition(), operationInputDefinitionList,
-                operationOutputDefinitionList,"update");
-
-        Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest
-                .validateInterfaceOperations(operations, component, false);
-        Assert.assertTrue(booleanResponseFormatEither.isLeft());
+        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
+        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(inputId));
+        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
+        InterfaceDefinition interfaceDefinition =
+                createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
+                        operationInputDefinitionList, operationOutputDefinitionList, "update");
+        Assert.assertTrue(interfaceOperationValidationUtilTest
+                                  .validateInterfaceOperations(interfaceDefinition, component,
+                                          component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
+                                  .isLeft());
     }
 
     @Test
     public void shouldFailWhenOperationOutputParamNamesAreNotUnique() {
-        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("inputParam1"));
-        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("outParam1"));
-        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("outParam2"));
-        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("outParam2"));
-        Collection<Operation> operations = createInterfaceOperationData("op2",
-                "interface operation2",new ArtifactDefinition(), operationInputDefinitionList,
-                operationOutputDefinitionList,"update");
-
-        Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest
-                .validateInterfaceOperations(operations, component, false);
-        Assert.assertTrue(booleanResponseFormatEither.isRight());
+        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
+        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(inputId));
+        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
+        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
+        InterfaceDefinition interfaceDefinition =
+                createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
+                        operationInputDefinitionList, operationOutputDefinitionList, "update");
+        Assert.assertTrue(interfaceOperationValidationUtilTest
+                                  .validateInterfaceOperations(interfaceDefinition, component,
+                                          component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
+                                  .isRight());
     }
 
-    private Set<Operation> createInterfaceOperationData( String uniqueID, String description, ArtifactDefinition artifactDefinition,
-                                                         ListDataDefinition<OperationInputDefinition> inputs,
-                                                         ListDataDefinition<OperationOutputDefinition> outputs, String name) {
-        return Sets.newHashSet(InterfaceOperationTestUtils.createInterfaceOperation(uniqueID, description, artifactDefinition, inputs, outputs, name));
+    @Test
+    public void shouldPassWhenOperationInputParamExistInComponentProperty() {
+        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
+        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
+        InterfaceDefinition interfaceDefinition =
+                createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
+                        operationInputDefinitionList, operationOutputDefinitionList, "update");
+        Assert.assertTrue(interfaceOperationValidationUtilTest
+                                  .validateInterfaceOperations(interfaceDefinition, component,
+                                          component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
+                                  .isLeft());
     }
 
-    private Component setUpComponentMock(){
-        Component component = new Resource();
-
-        List<InputDefinition> inputs = new ArrayList<>();
-        InputDefinition inputDefinition = new InputDefinition();
-        InputDefinition inputDefinition1 = new InputDefinition();
-
-        List<ComponentInstanceInput> componentInstanceInputs = new ArrayList<>();
-        ComponentInstanceInput componentInstanceInput1 = new ComponentInstanceInput();
-        componentInstanceInput1.setComponentInstanceName("componentInstance1");
-        componentInstanceInput1.setUniqueId("inputId1");
-        ComponentInstanceInput componentInstanceInput2 = new ComponentInstanceInput();
-        componentInstanceInput2.setComponentInstanceName("componentInstance2");
-        componentInstanceInput2.setUniqueId("inputId2");
-
-        componentInstanceInputs.add(componentInstanceInput1);
-        componentInstanceInputs.add(componentInstanceInput2);
+    @Test
+    public void shouldFailWhenOperationInputParamDoesntExistInComponentProperty() {
+        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
+        operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(operationId));
+        operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
+        InterfaceDefinition interfaceDefinition =
+                createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
+                        operationInputDefinitionList, operationOutputDefinitionList, "update");
+        Assert.assertTrue(interfaceOperationValidationUtilTest
+                                  .validateInterfaceOperations(interfaceDefinition, component,
+                                          component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
+                                  .isRight());
+    }
 
-        inputDefinition.setUniqueId("inputId1");
-        inputDefinition.setInputs(componentInstanceInputs);
-        inputDefinition1.setUniqueId("uniqueId3");
+    @Test
+    public void shouldFailValidateAllowedOperationCountOnLocalInterfaceType() {
+        InterfaceDefinition inputInterfaceDefinition =
+                InterfaceOperationTestUtils.createMockInterface(interfaceId, operationType);
+        Assert.assertTrue(interfaceOperationValidationUtilTest
+                                  .validateInterfaceOperations(inputInterfaceDefinition, component,
+                                          component.getInterfaces().get(interfaceId),
+                                          InterfaceOperationTestUtils.createMockInterfaceTypeMap(interfaceType,
+                                                  operationType),
+                                          false).isRight());
+    }
 
-        inputs.add(inputDefinition);
-        inputs.add(inputDefinition1);
-        component.setInputs(inputs);
-        component.setInterfaces(createMockInterfaceDefinition());
-        return  component;
+    @Test
+    public void shouldFailValidateAllowedOperationsOnGlobalInterfaceType() {
+        InterfaceDefinition inputInterfaceDefinition =
+                InterfaceOperationTestUtils.createMockInterface(interfaceType, operationId);
+        Assert.assertTrue(interfaceOperationValidationUtilTest
+                                  .validateInterfaceOperations(inputInterfaceDefinition, component,
+                                          component.getInterfaces().get(interfaceId),
+                                          InterfaceOperationTestUtils.createMockInterfaceTypeMap(interfaceType,
+                                                  operationType),
+                                          false).isRight());
     }
 
-    private  Map<String, InterfaceDefinition> createMockInterfaceDefinition() {
-        Map<String, Operation> operationMap = InterfaceOperationTestUtils.createMockOperationMap();
-        Map<String, InterfaceDefinition> interfaceDefinitionMap = new HashMap<>();
-        interfaceDefinitionMap.put("int1", InterfaceOperationTestUtils.createInterface("int1", "Interface 1",
-                "lifecycle", "tosca", operationMap));
+    @Test
+    public void shouldPassValidateAllowedOperationsOnGlobalInterfaceType() {
+        InterfaceDefinition inputInterfaceDefinition =
+                InterfaceOperationTestUtils.createMockInterface(interfaceType, operationType);
+        Assert.assertTrue(interfaceOperationValidationUtilTest
+                                  .validateInterfaceOperations(inputInterfaceDefinition, component,
+                                          component.getInterfaces().get(interfaceId),
+                                          InterfaceOperationTestUtils.createMockInterfaceTypeMap(interfaceType,
+                                                  operationType),
+                                          false).isLeft());
+    }
 
-        return interfaceDefinitionMap;
+    @Test
+    public void shouldFailValidateOperationNameUniquenessInCollection() {
+        InterfaceDefinition inputInterfaceDefinition =
+                InterfaceOperationTestUtils.createMockInterface(interfaceType, operationType);
+        inputInterfaceDefinition.getOperations()
+                .put(operationId, InterfaceOperationTestUtils.createMockOperation(operationType));
+        Assert.assertTrue(interfaceOperationValidationUtilTest
+                                  .validateInterfaceOperations(inputInterfaceDefinition, component,
+                                          component.getInterfaces().get(interfaceId),
+                                          InterfaceOperationTestUtils.createMockInterfaceTypeMap(interfaceType,
+                                                  operationType),
+                                          false).isRight());
     }
 
     private class InterfaceOperationValidationUtilTest extends InterfaceOperationValidation {
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/datamodel/utils/InterfaceUIDataConverterTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/datamodel/utils/InterfaceUIDataConverterTest.java
deleted file mode 100644
index 0c02e71bd2..0000000000
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/datamodel/utils/InterfaceUIDataConverterTest.java
+++ /dev/null
@@ -1,104 +0,0 @@
-package org.openecomp.sdc.be.datamodel.utils;
-
-import org.junit.Assert;
-import org.junit.Test;
-import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
-import org.openecomp.sdc.be.datatypes.elements.InterfaceOperationDataDefinition;
-import org.openecomp.sdc.be.datatypes.elements.InterfaceOperationParamDataDefinition;
-import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
-import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
-import org.openecomp.sdc.be.datatypes.elements.OperationOutputDefinition;
-import org.openecomp.sdc.be.model.Operation;
-
-import static org.openecomp.sdc.test.utils.InterfaceOperationTestUtils.createMockOperationInputDefinition;
-import static org.openecomp.sdc.test.utils.InterfaceOperationTestUtils.createMockOperationOutputDefinition;
-
-public class InterfaceUIDataConverterTest {
-
-	@Test
-	public void testConvertInterfaceDataToOperationData() {
-		InterfaceOperationDataDefinition interfaceOperation = createIODD("test",
-				"test description",
-				createParamDataList("inpName", "property", true, "String"),
-				createParamDataList("OutName", null, true, "String"),
-				"workflowId",
-				"workflowVersionId");
-		Operation result;
-		result = InterfaceUIDataConverter.convertInterfaceDataToOperationData(interfaceOperation);
-		Assert.assertNotNull(result);
-	}
-
-	@Test
-	public void testConvertInterfaceDataToOperationDataWithoutMandatory() {
-		ListDataDefinition<InterfaceOperationParamDataDefinition> iopd = new ListDataDefinition<>();
-		iopd.add(createParamData("test", "property", "String"));
-		InterfaceOperationDataDefinition interfaceOperation = createIODD("test",
-				"test description", iopd, iopd,
-				"workflowId",
-				"workflowVersionId");
-		Operation result;
-		result = InterfaceUIDataConverter.convertInterfaceDataToOperationData(interfaceOperation);
-		Assert.assertNotNull(result);
-	}
-
-	@Test
-	public void testConvertInterfaceDataToOperationDataWithoutOptionalFields() {
-		InterfaceOperationDataDefinition interfaceOperation = new InterfaceOperationDataDefinition();
-		interfaceOperation.setOperationType("operationType");
-		Operation result;
-		result = InterfaceUIDataConverter.convertInterfaceDataToOperationData(interfaceOperation);
-		Assert.assertNotNull(result);
-	}
-
-	@Test
-	public void testConvertOperationDataToInterfaceData() {
-		Operation operationData = new Operation();
-		InterfaceOperationDataDefinition result;
-		ListDataDefinition<OperationInputDefinition> inputs = new ListDataDefinition<>();
-		inputs.add(createMockOperationInputDefinition("Inp1"));
-		ListDataDefinition<OperationOutputDefinition> outputs = new ListDataDefinition<>();
-		outputs.add(createMockOperationOutputDefinition("out1"));
-		operationData.setInputs(inputs);
-		operationData.setOutputs(outputs);
-		operationData.setImplementation(new ArtifactDataDefinition());
-		result = InterfaceUIDataConverter.convertOperationDataToInterfaceData(operationData);
-		Assert.assertNotNull(result);
-	}
-
-	private InterfaceOperationDataDefinition createIODD(String operationType, String description,
-								ListDataDefinition<InterfaceOperationParamDataDefinition> inputParams,
-								ListDataDefinition<InterfaceOperationParamDataDefinition> outputParams,
-								String workflowId,
-								String workflowVersionId) {
-		InterfaceOperationDataDefinition interfaceOperation = new InterfaceOperationDataDefinition();
-		interfaceOperation.setOperationType(operationType);
-		interfaceOperation.setDescription(description);
-		interfaceOperation.setInputParams(inputParams);
-		interfaceOperation.setOutputParams(outputParams);
-		interfaceOperation.setWorkflowId(workflowId);
-		interfaceOperation.setWorkflowVersionId(workflowVersionId);
-		return interfaceOperation;
-	}
-
-	private InterfaceOperationParamDataDefinition createParamData(String name, String property, boolean mandatory, String type) {
-		InterfaceOperationParamDataDefinition definition = createParamData(name, property, type);
-		definition.setMandatory(mandatory);
-		return  definition;
-	}
-
-	private InterfaceOperationParamDataDefinition createParamData(String name, String property, String type) {
-		InterfaceOperationParamDataDefinition definition = new InterfaceOperationParamDataDefinition();
-		definition.setName(name);
-		definition.setProperty(property);
-		definition.setType(type);
-		return  definition;
-	}
-
-	private ListDataDefinition<InterfaceOperationParamDataDefinition> createParamDataList(String name,
-											String property, boolean mandatory, String type) {
-		ListDataDefinition<InterfaceOperationParamDataDefinition> list = new ListDataDefinition<>();
-		list.add(createParamData(name, property, mandatory, type));
-		return list;
-	}
-
-}
\ No newline at end of file
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java
index 2fabe43733..592d27ec5d 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java
@@ -1,6 +1,7 @@
 package org.openecomp.sdc.be.tosca;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -46,6 +47,7 @@ import org.openecomp.sdc.be.model.category.CategoryDefinition;
 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
 import org.openecomp.sdc.be.tosca.model.SubstitutionMapping;
 import org.openecomp.sdc.be.tosca.model.ToscaCapability;
 import org.openecomp.sdc.be.tosca.model.ToscaMetadata;
@@ -82,6 +84,9 @@ public class ToscaExportHandlerTest extends BeConfDependentTest {
 	@Mock
 	GroupExportParserImpl groupExportParserImpl;
 
+	@Mock
+	InterfaceLifecycleOperation interfaceLifecycleOperation;
+
 	@Before
 	public void setUpMock() throws Exception {
 		MockitoAnnotations.initMocks(this);
@@ -160,7 +165,7 @@ public class ToscaExportHandlerTest extends BeConfDependentTest {
 		((Resource) component).setInterfaces(new HashMap<>());
 
 		Mockito.when(dataTypeCache.getAll()).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND));
-
+		Mockito.when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(Collections.emptyMap()));
 		// default test when convertInterfaceNodeType is right
 		result = testSubject.exportComponentInterface(component, false);
 
@@ -392,6 +397,7 @@ public class ToscaExportHandlerTest extends BeConfDependentTest {
 		component.setInputs(inputs);
 
 		Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
+		Mockito.when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(Collections.emptyMap()));
 
 		Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class), Mockito.any(Resource.class),
 				Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
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 8f34e0e29b..983ef91a8c 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
@@ -19,6 +19,7 @@ package org.openecomp.sdc.be.tosca.utils;
 import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.databind.ObjectMapper;
 
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -63,15 +64,15 @@ public class InterfacesOperationsToscaUtilTest {
         Component component = new Resource();
         component.setNormalizedName("normalizedComponentName");
         InterfaceDefinition addedInterface = new InterfaceDefinition();
-        addedInterface.setToscaResourceName("interface.types.test_resource_name");
+        addedInterface.setType("interface.types.test_resource_name");
         addOperationsToInterface(addedInterface, 5, 3, true);
         final String interfaceType = "normalizedComponentName-interface";
         component.setInterfaces(new HashMap<>());
         component.getInterfaces().put(interfaceType, addedInterface);
         final Map<String, Object> interfaceTypeElement =
-                InterfacesOperationsToscaUtil.addInterfaceTypeElement(component);
+                InterfacesOperationsToscaUtil.addInterfaceTypeElement(component, new ArrayList<>());
 
-        ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null);
+        ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null);
         ToscaTemplate template = new ToscaTemplate("test");
         template.setInterface_types(interfaceTypeElement);
         final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template);
@@ -85,15 +86,15 @@ public class InterfacesOperationsToscaUtilTest {
         Component component = new Service();
         component.setNormalizedName("normalizedServiceComponentName");
         InterfaceDefinition addedInterface = new InterfaceDefinition();
-        addedInterface.setToscaResourceName("interface.types.test_service_name");
+        addedInterface.setType("interface.types.test_service_name");
         addOperationsToInterface(addedInterface, 5, 3, true);
         final String interfaceType = "normalizedServiceComponentName-interface";
         component.setInterfaces(new HashMap<>());
         component.getInterfaces().put(interfaceType, addedInterface);
         final Map<String, Object> interfaceTypeElement =
-                InterfacesOperationsToscaUtil.addInterfaceTypeElement(component);
+                InterfacesOperationsToscaUtil.addInterfaceTypeElement(component, new ArrayList<>());
 
-        ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null);
+        ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null);
         ToscaTemplate template = new ToscaTemplate("testService");
         template.setInterface_types(interfaceTypeElement);
         final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template);
@@ -107,7 +108,7 @@ public class InterfacesOperationsToscaUtilTest {
         Component component = new Resource();
         component.setNormalizedName("normalizedComponentName");
         InterfaceDefinition addedInterface = new InterfaceDefinition();
-        addedInterface.setToscaResourceName("com.some.resource.or.other.resourceName");
+        addedInterface.setType("com.some.resource.or.other.resourceName");
 
         addOperationsToInterface(addedInterface, 3, 2, true);
         final String interfaceType = "normalizedComponentName-interface";
@@ -116,7 +117,7 @@ public class InterfacesOperationsToscaUtilTest {
         ToscaNodeType nodeType = new ToscaNodeType();
         InterfacesOperationsToscaUtil.addInterfaceDefinitionElement(component, nodeType, false);
 
-        ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null);
+        ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null);
         ToscaTemplate template = new ToscaTemplate(NODE_TYPE_NAME);
         Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
         nodeTypes.put(NODE_TYPE_NAME, nodeType);
@@ -139,8 +140,7 @@ public class InterfacesOperationsToscaUtilTest {
         Component component = new Service();
         component.setNormalizedName("normalizedServiceComponentName");
         InterfaceDefinition addedInterface = new InterfaceDefinition();
-        addedInterface.setToscaResourceName("com.some.service.or.other.serviceName");
-
+        addedInterface.setType("com.some.service.or.other.serviceName");
         addOperationsToInterface(addedInterface, 3, 2, true);
         final String interfaceType = "normalizedServiceComponentName-interface";
         component.setInterfaces(new HashMap<>());
@@ -148,7 +148,7 @@ public class InterfacesOperationsToscaUtilTest {
         ToscaNodeType nodeType = new ToscaNodeType();
         InterfacesOperationsToscaUtil.addInterfaceDefinitionElement(component, nodeType, false);
 
-        ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null);
+        ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null);
         ToscaTemplate template = new ToscaTemplate("testService");
         Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
         nodeTypes.put(NODE_TYPE_NAME, nodeType);
@@ -170,8 +170,7 @@ public class InterfacesOperationsToscaUtilTest {
         Component component = new Resource();
         component.setNormalizedName("normalizedComponentName");
         InterfaceDefinition addedInterface = new InterfaceDefinition();
-        addedInterface.setToscaResourceName("com.some.resource.or.other.resourceNameNoInputs");
-
+        addedInterface.setType("com.some.resource.or.other.resourceNameNoInputs");
         addOperationsToInterface(addedInterface, 3, 3, false);
         final String interfaceType = "normalizedComponentName-interface";
         component.setInterfaces(new HashMap<>());
@@ -179,7 +178,7 @@ public class InterfacesOperationsToscaUtilTest {
         ToscaNodeType nodeType = new ToscaNodeType();
         InterfacesOperationsToscaUtil.addInterfaceDefinitionElement(component, nodeType, false);
 
-        ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null);
+        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);
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 10acd69a79..f21d5a9dcf 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
@@ -27,59 +27,47 @@ import org.openecomp.sdc.be.model.Operation;
 
 public class InterfaceOperationTestUtils {
 
-    public static InterfaceDefinition createInterface(String uniqueID, String description, String type,
-        String toscaResourceName, Map<String, Operation> op) {
+    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();
         id.setType(type);
         id.setDescription(description);
-        id.setUniqueId(uniqueID);
+        id.setUniqueId(uniqueId);
         id.setToscaResourceName(toscaResourceName);
         id.setOperationsMap(op);
         return id;
     }
 
-    public static Operation createInterfaceOperation(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);
-        return operation;
-    }
-
-    public static InterfaceDefinition mockInterfaceDefinitionToReturn(String resourceName) {
-        Map<String, Operation> operationMap = createMockOperationMap();
-        return createInterface("int1", "Interface 1",
-            "lifecycle", "org.openecomp.interfaces.node.lifecycle." + resourceName, operationMap);
-    }
-
-    public static Operation mockOperationToReturn() {
-        return createMockOperation();
-    }
-
-    public static Map<String, Operation> createMockOperationMap() {
+    public static Map<String, Operation> createMockOperationMap(String operationId) {
         Map<String, Operation> operationMap = new HashMap<>();
-        operationMap.put("op1", createMockOperation());
+        operationMap.put(operationId, createMockOperation(operationId));
         return operationMap;
     }
 
-    public static Operation createMockOperation() {
+    public static Operation createMockOperation(String operationId) {
         Operation operation = new Operation();
         ListDataDefinition<OperationInputDefinition> operationInputDefinitionList = new ListDataDefinition<>();
-        operationInputDefinitionList.add(createMockOperationInputDefinition("label1"));
+        operationInputDefinitionList.add(createMockOperationInputDefinition("inputId"));
         operation.setInputs(operationInputDefinitionList);
 
         ListDataDefinition<OperationOutputDefinition> operationOutputDefList = new ListDataDefinition<>();
-        operationOutputDefList.add(createMockOperationOutputDefinition("op1"));
+        operationOutputDefList.add(createMockOperationOutputDefinition("outputId"));
         operation.setOutputs(operationOutputDefList);
 
         operation.setDefinition(false);
-        operation.setName("CREATE");
-        operation.setUniqueId("uniqueId1");
+        operation.setName(operationId);
+        operation.setUniqueId(operationId);
         ArtifactDefinition implementation = new ArtifactDefinition();
         implementation.setUniqueId("uniqId");
         implementation.setArtifactUUID("artifactId");
@@ -89,28 +77,41 @@ public class InterfaceOperationTestUtils {
         return operation;
     }
 
-    public static OperationInputDefinition createMockOperationInputDefinition(String name) {
+    public static OperationInputDefinition createMockOperationInputDefinition(String inputId) {
         OperationInputDefinition operationInputDefinition = new OperationInputDefinition();
-        operationInputDefinition.setName(name);
-        operationInputDefinition.setUniqueId("uniqueId1");
-        operationInputDefinition.setInputId("inputId1");
+        operationInputDefinition.setName(inputId);
+        operationInputDefinition.setUniqueId(inputId);
+        operationInputDefinition.setInputId(inputId);
+        operationInputDefinition.setValue(inputId);
+        operationInputDefinition.setDefaultValue(inputId);
         return operationInputDefinition;
     }
 
-    public static OperationOutputDefinition createMockOperationOutputDefinition(String name) {
+    public static OperationOutputDefinition createMockOperationOutputDefinition(String outputId) {
         OperationOutputDefinition operationOutputDefinition = new OperationOutputDefinition();
-        operationOutputDefinition.setName(name);
-        operationOutputDefinition.setUniqueId("uniqueId1");
-        operationOutputDefinition.setInputId("inputId1");
+        operationOutputDefinition.setName(outputId);
+        operationOutputDefinition.setUniqueId(outputId);
+        operationOutputDefinition.setInputId(outputId);
+        operationOutputDefinition.setValue(outputId);
+        operationOutputDefinition.setDefaultValue(outputId);
         return operationOutputDefinition;
     }
 
-    public static Map<String, InterfaceDefinition> createMockInterfaceDefinition(String resourceName) {
-        Map<String, Operation> operationMap = createMockOperationMap();
+    public static Map<String, InterfaceDefinition> createMockInterfaceTypeMap(String interfaceType,
+            String operationType) {
+        Map<String, Operation> operationMap = createMockOperationTypeMap(operationType);
         Map<String, InterfaceDefinition> interfaceDefinitionMap = new HashMap<>();
-        interfaceDefinitionMap.put("int1", createInterface("int1", "Interface 1",
-            "lifecycle", "org.openecomp.interfaces.node.lifecycle." + resourceName, operationMap));
+        interfaceDefinitionMap.put(interfaceType,
+                createInterface(interfaceType, interfaceType, interfaceType, interfaceType, operationMap));
         return interfaceDefinitionMap;
     }
 
+    private static Map<String, Operation> createMockOperationTypeMap(String operationType) {
+        Operation operation = new Operation();
+        operation.setUniqueId(operationType);
+        Map<String, Operation> operationMap = new HashMap<>();
+        operationMap.put(operationType, operation);
+        return operationMap;
+    }
+
 }