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.

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

8 files changed, 493 insertions, 654 deletions

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..997d32691b 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,321 @@ 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.be.model.operations.impl.InterfaceLifecycleOperation;
 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;
-
+    @InjectMocks
+    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 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 static final String operationId1 = "operationId1";
+    private static final String interfaceId1 = "interfaceId1";
 
-    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();
-
-    @InjectMocks
-    private
-    InterfaceOperationBusinessLogic bl = new InterfaceOperationBusinessLogic();
+    private User user;
+    private Resource resource;
 
     @Before
     public void setup() {
-        MockitoAnnotations.initMocks(this);
-        Mockito.reset(propertyOperation);
-
-        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));
+        resource = new ResourceBuilder()
+            .setComponentType(ComponentTypeEnum.RESOURCE)
+            .setUniqueId(resourceId)
+            .setName(RESOURCE_NAME)
+            .build();
+        resource.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinitionMap(interfaceId, operationId));
+        resource.setInputs(createInputsForResource());
 
-        // Elements
-        IElementOperation mockElementDao = new ElementOperationMock();
-
-        // 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(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(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);
+        when(interfaceOperationValidation.validateInterfaceOperations(anyObject(), anyObject(), any(), anyMap(), anyBoolean())).thenReturn(Either.left(true));
+        when(titanDao.commit()).thenReturn(TitanOperationStatus.OK);
     }
 
     @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()));
-
-        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());
+    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 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()));
+        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());
+    @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 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());
     }
 
     @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 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());
+    }
 
-        Either<Operation, ResponseFormat> interfaceOperation = bl.createInterfaceOperation(resourceId, operation, user, true);
+    @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 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());
     }
 
-    @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 updateInterfaceOperationTestDoesntExist() {
+        when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(Collections.emptyMap()));
+        Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperation =
+            interfaceOperationBusinessLogic.updateInterfaceOperation(resourceId, Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId1)), user, true);
+        Assert.assertTrue(interfaceOperation.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 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());
     }
 
     @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 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());
+    }
 
-        Either<Operation, ResponseFormat> interfaceOperation = bl.updateInterfaceOperation(resourceId, operation, user, true);
-        Assert.assertTrue(interfaceOperation.isLeft());
+    @Test
+    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());
     }
 
-    @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 deleteInterfaceOperationTestInterfaceDoesntExist() {
+        Assert.assertTrue(interfaceOperationBusinessLogic.deleteInterfaceOperation(resourceId, interfaceId1, Collections.singletonList(operationId), 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 deleteInterfaceOperationTestOperationDoesntExist() {
+        Assert.assertTrue(interfaceOperationBusinessLogic.deleteInterfaceOperation(resourceId, interfaceId, Collections.singletonList(operationId1), user, true).isRight());
+    }
+
+    @Test
+    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();
+        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();
+        Either<Map<String, InterfaceDefinition>, ResponseFormat>  response = interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes();
         Assert.assertEquals(response.left().value().size(),1);
     }
+
+    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);
+    }
 }
\ 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..8884f9f2d6
--- /dev/null
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/utils/InterfaceOperationUtilsTest.java
@@ -0,0 +1,80 @@
+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..43d2fe884f 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,246 @@ 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 ResponseFormatManager responseFormatManagerMock;
-
     private final InterfaceOperationValidationUtilTest interfaceOperationValidationUtilTest = new InterfaceOperationValidationUtilTest();
     private final ListDataDefinition<OperationInputDefinition> operationInputDefinitionList = new ListDataDefinition<>();
     private final ListDataDefinition<OperationOutputDefinition> operationOutputDefinitionList = new ListDataDefinition<>();
+    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 Component component;
+    private ResponseFormatManager responseFormatManagerMock;
 
     @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());
+        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());
     }
 
     @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 shouldFailWhenOperationNameIsEmpty() {
+        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 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());
+    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 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 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("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 " +
+        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");
-        Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest
-                .validateInterfaceOperations(operations, component, false);
-        Assert.assertTrue(booleanResponseFormatEither.isRight());
+        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();
+    @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());
+    }
 
-        List<InputDefinition> inputs = new ArrayList<>();
-        InputDefinition inputDefinition = new InputDefinition();
-        InputDefinition inputDefinition1 = new InputDefinition();
+    @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());
+    }
+
+    @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());
+    }
 
-        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);
-
-        inputDefinition.setUniqueId("inputId1");
-        inputDefinition.setInputs(componentInstanceInputs);
-        inputDefinition1.setUniqueId("uniqueId3");
-
-        inputs.add(inputDefinition);
-        inputs.add(inputDefinition1);
-        component.setInputs(inputs);
-        component.setInterfaces(createMockInterfaceDefinition());
-        return  component;
+    @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());
     }
 
-    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 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());
+    }
 
-        return interfaceDefinitionMap;
+    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;
+    }
+
+    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);
     }
 
     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..4bda41671d 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,7 +27,7 @@ import org.openecomp.sdc.be.model.Operation;
 
 public class InterfaceOperationTestUtils {
 
-    public static InterfaceDefinition createInterface(String uniqueID, String description, String type,
+    private static InterfaceDefinition createInterface(String uniqueID, String description, String type,
         String toscaResourceName, Map<String, Operation> op) {
         InterfaceDefinition id = new InterfaceDefinition();
         id.setType(type);
@@ -38,48 +38,35 @@ public class InterfaceOperationTestUtils {
         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 Map<String, InterfaceDefinition> createMockInterfaceDefinitionMap(String interfaceId, String operationId) {
+        Map<String, InterfaceDefinition> interfaceDefinitionMap = new HashMap<>();
+        interfaceDefinitionMap.put(interfaceId, createMockInterface(interfaceId, operationId));
+        return interfaceDefinitionMap;
     }
 
-    public static Operation mockOperationToReturn() {
-        return createMockOperation();
+    public static InterfaceDefinition createMockInterface(String interfaceId, String operationId) {
+        return createInterface(interfaceId, interfaceId, interfaceId, interfaceId, createMockOperationMap(operationId));
     }
 
-    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 +76,39 @@ 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;
+    }
+
 }