Support interface input during import VFC

Change-Id: I097ce258a7dadbedf1aff6ce53dd1286da074552
Issue-ID: SDC-3372
Signed-off-by: andre.schmid <andre.schmid@est.tech>

15 files changed, 836 insertions, 419 deletions

diff --git a/catalog-be/src/main/docker/backend/chef-repo/cookbooks/sdc-catalog-be/files/default/error-configuration.yaml b/catalog-be/src/main/docker/backend/chef-repo/cookbooks/sdc-catalog-be/files/default/error-configuration.yaml
index d2a79909d6..4aa93cb268 100644
--- a/catalog-be/src/main/docker/backend/chef-repo/cookbooks/sdc-catalog-be/files/default/error-configuration.yaml
+++ b/catalog-be/src/main/docker/backend/chef-repo/cookbooks/sdc-catalog-be/files/default/error-configuration.yaml
@@ -2060,6 +2060,18 @@ errors:
       message: "Error: Failed to delete interface operation.",
       messageId: "SVC4702"
     }
+    #SVC4732
+    INTERFACE_UNKNOWN: {
+        code: 400,
+        message: "Error: The interface '%1' does not exists in the database.",
+        messageId: "SVC4732"
+    }
+    #SVC4733
+    INTERFACE_OPERATION_NOT_DEFINED: {
+        code: 400,
+        message: "Error: The operation '%1' does not exists in the interface '%2'.",
+        messageId: "SVC4733"
+    }
     #-----------SVC4692---------------------------
     RESOURCE_LIFECYCLE_STATE_NOT_VALID: {
         code: 400,
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ImportUtils.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ImportUtils.java
index 4127faa820..614b261b4a 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ImportUtils.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ImportUtils.java
@@ -47,6 +47,7 @@ import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentEx
 import org.openecomp.sdc.be.config.BeEcompErrorManager;
 import org.openecomp.sdc.be.dao.api.ActionStatus;
 import org.openecomp.sdc.be.datatypes.elements.Annotation;
+import org.openecomp.sdc.be.datatypes.elements.AttributeDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
@@ -348,24 +349,24 @@ public final class ImportUtils {
         }
     }
 
-    private static List<PropertyConstraint> getPropertyConstraints(Map<String, Object> propertyValue,
-                                                                   String propertyType) {
-        List<Object> propertyFieldConstraints = findCurrentLevelConstraintsElement(propertyValue);
-        if (CollectionUtils.isNotEmpty(propertyFieldConstraints)) {
-            List<PropertyConstraint> constraintList = new ArrayList<>();
-            Type constraintType = new TypeToken<PropertyConstraint>() {
-            }.getType();
-            Gson gson = new GsonBuilder().registerTypeAdapter(constraintType, new PropertyConstraintDeserialiser())
-                .create();
+    private static List<PropertyConstraint> getPropertyConstraints(final Map<String, Object> propertyValue,
+                                                                   final String propertyType) {
+        final List<Object> propertyFieldConstraints = findCurrentLevelConstraintsElement(propertyValue);
+        if (CollectionUtils.isEmpty(propertyFieldConstraints)) {
+            return Collections.emptyList();
+        }
+        final List<PropertyConstraint> constraintList = new ArrayList<>();
+        final Type constraintType = new TypeToken<PropertyConstraint>() {
+        }.getType();
+        final Gson gson = new GsonBuilder().registerTypeAdapter(constraintType, new PropertyConstraintDeserialiser())
+            .create();
 
-            for (Object constraintJson : propertyFieldConstraints) {
-                PropertyConstraint propertyConstraint = validateAndGetPropertyConstraint(propertyType, constraintType,
-                    gson, constraintJson);
-                constraintList.add(propertyConstraint);
-            }
-            return constraintList;
+        for (final Object constraintJson : propertyFieldConstraints) {
+            final PropertyConstraint propertyConstraint = validateAndGetPropertyConstraint(propertyType, constraintType,
+                gson, constraintJson);
+            constraintList.add(propertyConstraint);
         }
-        return null;
+        return constraintList;
     }
 
     private static List<Object> findCurrentLevelConstraintsElement(Map<String, Object> toscaJson) {
@@ -485,10 +486,13 @@ public final class ImportUtils {
         return result;
     }
 
-    public static InputDefinition createModuleInput(Map<String, Object> inputValue,
-                                                    AnnotationTypeOperations annotationTypeOperations) {
+    public static InputDefinition createModuleInput(final Map<String, Object> inputValue,
+                                                    final AnnotationTypeOperations annotationTypeOperations) {
+        return parseAnnotationsAndAddItToInput(createModuleInput(inputValue), inputValue, annotationTypeOperations);
+    }
 
-        InputDefinition inputDef = new InputDefinition();
+    public static InputDefinition createModuleInput(final Map<String, Object> inputValue) {
+        final InputDefinition inputDef = new InputDefinition();
         setField(inputValue, TypeUtils.ToscaTagNamesEnum.TYPE, inputDef::setType);
         setFieldBoolean(inputValue, ToscaTagNamesEnum.REQUIRED, req -> inputDef.setRequired(Boolean.parseBoolean(req)));
         setField(inputValue, TypeUtils.ToscaTagNamesEnum.DESCRIPTION, inputDef::setDescription);
@@ -504,9 +508,7 @@ public final class ImportUtils {
 
         setScheme(inputValue, inputDef);
         setPropertyConstraints(inputValue, inputDef);
-
-        return parseAnnotationsAndAddItToInput(inputDef, inputValue, annotationTypeOperations);
-
+        return inputDef;
     }
 
     public static InputDefinition parseAnnotationsAndAddItToInput(InputDefinition inputDef,
@@ -608,6 +610,11 @@ public final class ImportUtils {
 
     }
 
+    public static Either<Map<String, InputDefinition>, ResultStatusEnum> getInputs(final Map<String, Object> toscaJson) {
+        return getElements(toscaJson, TypeUtils.ToscaTagNamesEnum.INPUTS, ImportUtils::createInputs,
+            ImportUtils::createModuleInput);
+    }
+
     public static <T> Either<Map<String, T>, ResultStatusEnum> getElements(Map<String, Object> toscaJson,
                                                                            TypeUtils.ToscaTagNamesEnum elementTagName,
                                                                            Function<String, T> elementGenByName,
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceDefinitionHandler.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceDefinitionHandler.java
new file mode 100644
index 0000000000..aeb4376c15
--- /dev/null
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceDefinitionHandler.java
@@ -0,0 +1,255 @@
+/*
+ * ============LICENSE_START=======================================================
+ *  Copyright (C) 2020 Nordix Foundation
+ *  ================================================================================
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *  SPDX-License-Identifier: Apache-2.0
+ *  ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.be.components.impl;
+
+import static org.openecomp.sdc.be.components.impl.ImportUtils.Constants.QUOTE;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DEFAULT;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DESCRIPTION;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.IMPLEMENTATION;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.INPUTS;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.NOTIFICATIONS;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.OPERATIONS;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.REQUIRED;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.STATUS;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.TYPE;
+
+import fj.data.Either;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import org.apache.commons.collections.MapUtils;
+import org.openecomp.sdc.be.components.impl.ImportUtils.ResultStatusEnum;
+import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
+import org.openecomp.sdc.be.dao.api.ActionStatus;
+import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.InputDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
+import org.openecomp.sdc.be.model.InputDefinition;
+import org.openecomp.sdc.be.model.InterfaceDefinition;
+import org.openecomp.sdc.be.tosca.utils.OperationArtifactUtil;
+import org.openecomp.sdc.exception.ResponseFormat;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+
+/**
+ * Handles interface definition TOSCA conversions
+ */
+@Component("interfaceDefinitionHandler")
+public class InterfaceDefinitionHandler {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(InterfaceDefinitionHandler.class);
+
+    private final InterfaceOperationBusinessLogic interfaceOperationBusinessLogic;
+
+    public InterfaceDefinitionHandler(final InterfaceOperationBusinessLogic interfaceOperationBusinessLogic) {
+        this.interfaceOperationBusinessLogic = interfaceOperationBusinessLogic;
+    }
+
+    /**
+     * Creates an interface definition based on a TOSCA map representing an interface definition.
+     *
+     * @param interfaceDefinitionToscaMap the TOSCA interface definition structure
+     * @return an interface definition representation
+     */
+    public InterfaceDefinition create(final Map<String, Object> interfaceDefinitionToscaMap) {
+
+        final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
+
+        if (interfaceDefinitionToscaMap.containsKey(TYPE.getElementName())) {
+            final Object typeObj = interfaceDefinitionToscaMap.get(TYPE.getElementName());
+            if (!(typeObj instanceof String)) {
+                throw new ByActionStatusComponentException(ActionStatus.INVALID_YAML);
+            }
+            final String type = (String) typeObj;
+            interfaceDefinition.setType(type);
+            interfaceDefinition.setUniqueId(type.toLowerCase());
+        }
+
+        final Map<String, InputDefinition> inputDefinitionMap = handleInputs(interfaceDefinitionToscaMap);
+        if (!inputDefinitionMap.isEmpty()) {
+            final Map<String, InputDataDefinition> collect = inputDefinitionMap.entrySet().stream().
+                collect(Collectors.toMap(Entry::getKey, value -> new InputDataDefinition(value.getValue())));
+            interfaceDefinition.setInputs(collect);
+        }
+        final Map<String, OperationDataDefinition> operationMap;
+        if (interfaceDefinitionToscaMap.containsKey(OPERATIONS.getElementName()) || interfaceDefinitionToscaMap
+            .containsKey(NOTIFICATIONS.getElementName())) {
+            operationMap = handleOperations(interfaceDefinitionToscaMap);
+            //TODO handle notifications
+        } else {
+            operationMap = handleLegacyOperations(interfaceDefinitionToscaMap);
+        }
+        if (!operationMap.isEmpty()) {
+            validateOperations(interfaceDefinition.getType(), operationMap);
+            interfaceDefinition.setOperations(operationMap);
+        }
+
+        return interfaceDefinition;
+    }
+
+    private void validateOperations(final String interfaceType,
+                                    final Map<String, OperationDataDefinition> operationMap) {
+        if (MapUtils.isEmpty(operationMap)) {
+            return;
+        }
+        Either<Map<String, InterfaceDefinition>, ResponseFormat> interfaceDefinitionMapEither =
+            interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes();
+        if (interfaceDefinitionMapEither.isRight() || MapUtils.isEmpty(interfaceDefinitionMapEither.left().value())) {
+            throw new ByActionStatusComponentException(ActionStatus.INTERFACE_UNKNOWN, interfaceType);
+        }
+
+        final Map<String, InterfaceDefinition> interfaceDefinitionMap = interfaceDefinitionMapEither.left().value();
+        final Optional<InterfaceDefinition> interfaceDefinitionOptional = interfaceDefinitionMap.entrySet().stream()
+            .filter(interfaceDefinitionEntry -> interfaceDefinitionEntry.getKey().equalsIgnoreCase(interfaceType))
+            .map(Entry::getValue).findFirst();
+        if (interfaceDefinitionOptional.isEmpty()) {
+            throw new ByActionStatusComponentException(ActionStatus.INTERFACE_UNKNOWN, interfaceType);
+        }
+        final InterfaceDefinition interfaceDefinition = interfaceDefinitionOptional.get();
+        operationMap.keySet().forEach(operation1 -> {
+            if (!interfaceDefinition.hasOperation(operation1)) {
+                throw new ByActionStatusComponentException(ActionStatus.INTERFACE_OPERATION_NOT_DEFINED,
+                    operation1, interfaceType);
+            }
+        });
+    }
+
+    private Map<String, OperationDataDefinition> handleOperations(
+        final Map<String, Object> interfaceDefinitionToscaMap) {
+        if (!interfaceDefinitionToscaMap.containsKey(OPERATIONS.getElementName())) {
+            return Collections.emptyMap();
+        }
+        final Map<String, Object> operationMap =
+            (Map<String, Object>) interfaceDefinitionToscaMap.get(OPERATIONS.getElementName());
+        return operationMap.entrySet().stream()
+            .map(interfaceEntry -> createOperation(interfaceEntry.getKey(),
+                (Map<String, Object>) interfaceEntry.getValue()))
+            .collect(
+                Collectors.toMap(OperationDataDefinition::getName, operationDataDefinition -> operationDataDefinition));
+    }
+
+    private Map<String, OperationDataDefinition> handleLegacyOperations(
+        final Map<String, Object> interfaceDefinitionToscaMap) {
+        final List<String> notALegacyOperationEntry = Arrays
+            .asList(OPERATIONS.getElementName(),
+                TYPE.getElementName(),
+                INPUTS.getElementName(),
+                NOTIFICATIONS.getElementName());
+        return interfaceDefinitionToscaMap.entrySet().stream()
+            .filter(interfaceEntry -> !notALegacyOperationEntry.contains(interfaceEntry.getKey()))
+            .map(interfaceEntry -> createOperation(interfaceEntry.getKey(),
+                (Map<String, Object>) interfaceEntry.getValue()))
+            .collect(
+                Collectors.toMap(OperationDataDefinition::getName, operationDataDefinition -> operationDataDefinition));
+    }
+
+
+    private OperationDataDefinition createOperation(final String operationName,
+                                                    final Map<String, Object> operationDefinitionMap) {
+        final OperationDataDefinition operation = new OperationDataDefinition();
+        operation.setName(operationName);
+
+        handleOperationImplementation(operationDefinitionMap).ifPresent(operation::setImplementation);
+        if (operationDefinitionMap.containsKey(INPUTS.getElementName())) {
+            final Map<String, Object> interfaceInputs =
+                (Map<String, Object>) operationDefinitionMap.get(INPUTS.getElementName());
+            operation.setInputs(handleInterfaceOperationInputs(interfaceInputs));
+        }
+
+        return operation;
+    }
+
+    private ListDataDefinition<OperationInputDefinition> handleInterfaceOperationInputs(
+        final Map<String, Object> interfaceInputs) {
+        final ListDataDefinition<OperationInputDefinition> inputs = new ListDataDefinition<>();
+        for (final Entry<String, Object> interfaceInput : interfaceInputs.entrySet()) {
+            final OperationInputDefinition operationInput = new OperationInputDefinition();
+            operationInput.setName(interfaceInput.getKey());
+            if (interfaceInput.getValue() instanceof Map) {
+                final LinkedHashMap<String, Object> inputPropertyValue =
+                    (LinkedHashMap<String, Object>) interfaceInput.getValue();
+                LOGGER.info("createModuleInterface: i interfaceInput.getKey() {}, {} , {}  ",
+                    interfaceInput.getKey(), inputPropertyValue.keySet(), inputPropertyValue.values());
+                if (inputPropertyValue.get(TYPE.getElementName()) != null) {
+                    operationInput.setType(inputPropertyValue.get(TYPE.getElementName()).toString());
+                }
+                if (inputPropertyValue.get(DESCRIPTION.getElementName()) != null) {
+                    operationInput.setDescription(inputPropertyValue.get(DESCRIPTION.getElementName()).toString());
+                }
+                if (inputPropertyValue.get(REQUIRED.getElementName()) != null) {
+                    operationInput.setRequired(
+                        Boolean.getBoolean(inputPropertyValue.get(REQUIRED.getElementName()).toString()));
+                }
+                if (inputPropertyValue.get(DEFAULT.getElementName()) != null) {
+                    operationInput.setToscaDefaultValue(inputPropertyValue.get(DEFAULT.getElementName()).toString());
+                }
+                if (inputPropertyValue.get(STATUS.getElementName()) != null) {
+                    operationInput.setStatus(inputPropertyValue.get(STATUS.getElementName()).toString());
+                }
+
+            } else if (interfaceInput.getValue() instanceof String) {
+                final String value = (String) interfaceInput.getValue();
+                operationInput.setDefaultValue(value);
+                operationInput.setToscaDefaultValue(value);
+                operationInput.setValue(value);
+            }
+            inputs.add(operationInput);
+        }
+        return inputs;
+    }
+
+    private Optional<ArtifactDataDefinition> handleOperationImplementation(
+        final Map<String, Object> operationDefinitionMap) {
+        if (!operationDefinitionMap.containsKey(IMPLEMENTATION.getElementName())) {
+            return Optional.empty();
+        }
+        final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
+        final String artifactName = (String) operationDefinitionMap.get(IMPLEMENTATION.getElementName());
+        if (OperationArtifactUtil.artifactNameIsALiteralValue(artifactName)) {
+            artifactDataDefinition.setArtifactName(artifactName);
+        } else {
+            artifactDataDefinition.setArtifactName(QUOTE + artifactName + QUOTE);
+        }
+        return Optional.of(artifactDataDefinition);
+    }
+
+    private Map<String, InputDefinition> handleInputs(final Map<String, Object> interfaceDefinitionToscaMap) {
+        if (!interfaceDefinitionToscaMap.containsKey(INPUTS.getElementName())) {
+            return Collections.emptyMap();
+        }
+
+        final Either<Map<String, InputDefinition>, ResultStatusEnum> inputMapEither =
+            ImportUtils.getInputs(interfaceDefinitionToscaMap);
+        if (inputMapEither.isRight()) {
+            return Collections.emptyMap();
+        }
+
+        return inputMapEither.left().value();
+    }
+
+}
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ResourceImportManager.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ResourceImportManager.java
index 7ff916df32..b96e4e58e2 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ResourceImportManager.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ResourceImportManager.java
@@ -22,7 +22,6 @@
 
 package org.openecomp.sdc.be.components.impl;
 
-import static org.openecomp.sdc.be.components.impl.ImportUtils.Constants.QUOTE;
 import static org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaElementOperation.createDataType;
 import static org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaElementOperation.createDataTypeDefinitionWithName;
 import static org.openecomp.sdc.be.utils.TypeUtils.setField;
@@ -34,7 +33,6 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
@@ -62,11 +60,7 @@ import org.openecomp.sdc.be.config.BeEcompErrorManager;
 import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity;
 import org.openecomp.sdc.be.dao.api.ActionStatus;
 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
-import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.AttributeDataDefinition;
-import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
-import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
-import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
@@ -94,7 +88,6 @@ import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
 import org.openecomp.sdc.be.resources.data.auditing.model.CommonAuditData;
 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceCommonInfo;
 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceVersionInfo;
-import org.openecomp.sdc.be.tosca.utils.OperationArtifactUtil;
 import org.openecomp.sdc.be.utils.TypeUtils;
 import org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum;
 import org.openecomp.sdc.common.log.wrappers.Logger;
@@ -112,13 +105,7 @@ public class ResourceImportManager {
     private static final Logger log = Logger.getLogger(ResourceImportManager.class);
 
     static final Pattern PROPERTY_NAME_PATTERN_IGNORE_LENGTH = Pattern.compile("[\\w\\-\\_\\d\\:]+");
-    private static final String IMPLEMENTATION = "implementation";
-    private static final String INPUTS = "inputs";
-    private static final String TYPE = "type";
-    private static final String DESCRIPTION = "description";
-    private static final String REQUIRED = "required";
-    private static final String DEFAULT = "default";
-    private static final String STATUS = "status";
+    private final InterfaceDefinitionHandler interfaceDefinitionHandler;
 
     private ServletContext servletContext;
 
@@ -134,7 +121,6 @@ public class ResourceImportManager {
 
     @Autowired
     private ServiceBusinessLogic serviceBusinessLogic;
-    private InterfaceOperationBusinessLogic interfaceOperationBusinessLogic;
 
     private IGraphLockOperation graphLockOperation;
     private ToscaOperationFacade toscaOperationFacade;
@@ -145,9 +131,11 @@ public class ResourceImportManager {
     private ResponseFormatManager responseFormatManager;
 
     @Autowired
-    public ResourceImportManager(ComponentsUtils componentsUtils, CapabilityTypeOperation capabilityTypeOperation) {
+    public ResourceImportManager(ComponentsUtils componentsUtils, CapabilityTypeOperation capabilityTypeOperation,
+                                 final InterfaceDefinitionHandler interfaceDefinitionHandler) {
         this.componentsUtils = componentsUtils;
         this.capabilityTypeOperation = capabilityTypeOperation;
+        this.interfaceDefinitionHandler = interfaceDefinitionHandler;
     }
 
     @Autowired
@@ -380,11 +368,9 @@ public class ResourceImportManager {
         if (toscaInterfaces.isLeft()) {
             Map<String, Object> jsonInterfaces = toscaInterfaces.left().value();
             Map<String, InterfaceDefinition> moduleInterfaces = new HashMap<>();
-            Iterator<Entry<String, Object>> interfacesNameValue = jsonInterfaces.entrySet().iterator();
-            while (interfacesNameValue.hasNext()) {
-                Entry<String, Object> interfaceNameValue = interfacesNameValue.next();
-                Either<InterfaceDefinition, ResultStatusEnum> eitherInterface = createModuleInterface(interfaceNameValue
-                    .getValue(), resource);
+            for (final Entry<String, Object> interfaceNameValue : jsonInterfaces.entrySet()) {
+                final Either<InterfaceDefinition, ResultStatusEnum> eitherInterface =
+                    createModuleInterface(interfaceNameValue.getValue());
                 if (eitherInterface.isRight()) {
                     log.info("error when creating interface:{}, for resource:{}", interfaceNameValue.getKey(),
                         resource.getName());
@@ -393,165 +379,32 @@ public class ResourceImportManager {
                 }
 
             }
-            if (moduleInterfaces.size() > 0) {
+            if (!moduleInterfaces.isEmpty()) {
                 resource.setInterfaces(moduleInterfaces);
             }
         }
     }
 
-    private Either<InterfaceDefinition, ResultStatusEnum> createModuleInterface(Object interfaceJson,
-                                                                                Resource resource) {
-        final InterfaceDefinition interf = new InterfaceDefinition();
-        Either<InterfaceDefinition, ResultStatusEnum> result = Either.left(interf);
-
+    private Either<InterfaceDefinition, ResultStatusEnum> createModuleInterface(final Object interfaceJson) {
         try {
             if (interfaceJson instanceof String) {
-                final String requirementJsonString = (String) interfaceJson;
-                interf.setType(requirementJsonString);
-            } else if (interfaceJson instanceof Map && ResourceTypeEnum.VFC.equals(resource.getResourceType())) {
-                final Map<String, Object> requirementJsonMap = (Map<String, Object>) interfaceJson;
-                final Map<String, OperationDataDefinition> operations = new HashMap<>();
-
-                for (final Entry<String, Object> entry : requirementJsonMap.entrySet()) {
-                    if (entryIsInterfaceType(entry)) {
-                        final String type = (String) requirementJsonMap
-                            .get(TypeUtils.ToscaTagNamesEnum.TYPE.getElementName());
-                        interf.setType(type);
-                        interf.setUniqueId(type.toLowerCase());
-                    } else if (entryContainsImplementationForAKnownOperation(entry, interf.getType())) {
-
-                        final OperationDataDefinition operation = new OperationDataDefinition();
-                        operation.setName(entry.getKey());
-
-                        final Map<?, ?> entryValue = (Map<?, ?>) entry.getValue();
-                        if (entryValue.containsKey(IMPLEMENTATION)) {
-                            operation.setImplementation(handleOperationImplementation(entry));
-                        }
-                        if (entryValue.containsKey(INPUTS)) {
-                            final Map<String, Object> interfaceInputs = (Map<String, Object>) entryValue
-                                .get(ToscaTagNamesEnum.INPUTS.getElementName());
-                            operation.setInputs(handleInterfaceInput(interfaceInputs));
-                        }
-                        operations.put(entry.getKey(), operation);
-                    }
-                }
-                if (!operations.isEmpty()) {
-                    interf.setOperations(operations);
-                }
-            } else {
-                result = Either.right(ResultStatusEnum.GENERAL_ERROR);
-            }
-
-        } catch (Exception e) {
-            BeEcompErrorManager.getInstance().logBeSystemError("Import Resource- create interface");
-            log.debug("error when creating interface, message:{}", e.getMessage(), e);
-            result = Either.right(ResultStatusEnum.GENERAL_ERROR);
-        }
-
-        return result;
-    }
-
-    private ArtifactDataDefinition handleOperationImplementation(final Entry<String, Object> entry) {
-        final ArtifactDataDefinition implementation = new ArtifactDataDefinition();
-        final String artifactName = ((Map<String, String>) entry.getValue()).get(IMPLEMENTATION);
-        if (OperationArtifactUtil.artifactNameIsALiteralValue(artifactName)) {
-            implementation.setArtifactName(artifactName);
-        } else {
-            implementation.setArtifactName(QUOTE + artifactName + QUOTE);
-        }
-        return implementation;
-    }
-
-    private ListDataDefinition<OperationInputDefinition> handleInterfaceInput(
-        final Map<String, Object> interfaceInputs) {
-        final ListDataDefinition<OperationInputDefinition> inputs = new ListDataDefinition<>();
-        for (final Entry<String, Object> interfaceInput : interfaceInputs.entrySet()) {
-            final OperationInputDefinition operationInput = new OperationInputDefinition();
-            operationInput.setName(interfaceInput.getKey());
-            if (interfaceInput.getValue() instanceof Map) {
-                final LinkedHashMap<String, Object> inputPropertyValue =
-                    (LinkedHashMap<String, Object>) interfaceInput.getValue();
-                log.info("createModuleInterface: i interfaceInput.getKey() {}, {} , {}  ",
-                    interfaceInput.getKey(), inputPropertyValue.keySet(),
-                    inputPropertyValue.values());
-                if (inputPropertyValue.get(TYPE) != null) {
-                    operationInput.setType(inputPropertyValue.get(TYPE).toString());
-                }
-                if (inputPropertyValue.get(DESCRIPTION) != null) {
-                    operationInput.setDescription(inputPropertyValue.get(DESCRIPTION).toString());
-                }
-                if (inputPropertyValue.get(REQUIRED) != null) {
-                    operationInput.setRequired(
-                        Boolean.getBoolean(inputPropertyValue.get(REQUIRED).toString()));
-                }
-                if (inputPropertyValue.get(DEFAULT) != null) {
-                    operationInput.setToscaDefaultValue(inputPropertyValue.get(DEFAULT).toString());
-                }
-                if (inputPropertyValue.get(STATUS) != null) {
-                    operationInput.setStatus(inputPropertyValue.get(STATUS).toString());
-                }
-
-            } else if (interfaceInput.getValue() instanceof String) {
-                final String value = (String) interfaceInput.getValue();
-                operationInput.setDefaultValue(value);
-                operationInput.setToscaDefaultValue(value);
-                operationInput.setValue(value);
+                final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
+                interfaceDefinition.setType((String) interfaceJson);
+                return Either.left(interfaceDefinition);
             }
-            inputs.getListToscaDataDefinition().add(operationInput);
-            inputs.add(operationInput);
-        }
-        return inputs;
-    }
 
-    private boolean entryIsInterfaceType(final Entry<String, Object> entry) {
-        if(entry.getKey().equals(TypeUtils.ToscaTagNamesEnum.TYPE.getElementName())) {
-            if (entry.getValue() instanceof String) {
-                return true;
+            if (interfaceJson instanceof Map) {
+                final Map<String, Object> interfaceJsonMap = (Map<String, Object>) interfaceJson;
+                final InterfaceDefinition interfaceDefinition = interfaceDefinitionHandler.create(interfaceJsonMap);
+                return Either.left(interfaceDefinition);
             }
-            throw new ByActionStatusComponentException(ActionStatus.INVALID_YAML);
-        }
-        return false;
-    }
-
-    private boolean entryContainsImplementationForAKnownOperation(final Entry<String, Object> entry,
-                                                                  final String interfaceType) {
-        if (entry.getValue() instanceof Map && ((Map<?, ?>)entry.getValue()).containsKey(IMPLEMENTATION)) {
-            if (isAKnownOperation(interfaceType, entry.getKey())){
-                return true;
-            }
-            throw new ByActionStatusComponentException(ActionStatus.INTERFACE_OPERATION_NOT_FOUND);
-        }
-        return false;
-    }
-
-    private boolean isAKnownOperation(String interfaceType, String operation) {
-        Either<Map<String, InterfaceDefinition>, ResponseFormat> interfaceLifecycleTypes = interfaceOperationBusinessLogic
-            .getAllInterfaceLifecycleTypes();
-        if (interfaceLifecycleTypes.isRight() || interfaceLifecycleTypes.left().value() == null) {
-            return false;
-        }
 
-        for (Entry<String, InterfaceDefinition> interfaceLifecycleType : interfaceLifecycleTypes.left().value()
-            .entrySet()) {
-            if (interfaceTypeAndOperationMatches(interfaceLifecycleType, interfaceType, operation)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    private boolean interfaceTypeAndOperationMatches(Entry<String, InterfaceDefinition> interfaceLifecycleType,
-                                                     String interfaceType, String operation) {
-        if (interfaceLifecycleType.getKey().equalsIgnoreCase(interfaceType)
-            && interfaceLifecycleType.getValue().getOperations() != null) {
-            for (String interfaceLifecycleTypeOperation : interfaceLifecycleType.getValue().getOperations().keySet()) {
-                if (interfaceLifecycleTypeOperation != null && interfaceLifecycleTypeOperation
-                    .equalsIgnoreCase(operation)) {
-                    return true;
-                }
-            }
+            return Either.right(ResultStatusEnum.GENERAL_ERROR);
+        } catch (final Exception e) {
+            BeEcompErrorManager.getInstance().logBeSystemError("Import Resource- create interface");
+            log.debug("error when creating interface, message:{}", e.getMessage(), e);
+            return Either.right(ResultStatusEnum.GENERAL_ERROR);
         }
-        return false;
     }
 
     private void setRequirements(Map<String, Object> toscaJson, Resource resource,
@@ -1165,11 +1018,6 @@ public class ResourceImportManager {
         this.resourceBusinessLogic = resourceBusinessLogic;
     }
 
-    @Autowired
-    public void setInterfaceOperationBusinessLogic(InterfaceOperationBusinessLogic interfaceOperationBusinessLogic) {
-        this.interfaceOperationBusinessLogic = interfaceOperationBusinessLogic;
-    }
-
     public IGraphLockOperation getGraphLockOperation() {
         return graphLockOperation;
     }
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/InterfacesOperationsConverter.java b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/InterfacesOperationsConverter.java
index 9e9d834691..1f1dcfed8c 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/InterfacesOperationsConverter.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/InterfacesOperationsConverter.java
@@ -16,10 +16,21 @@
 
 package org.openecomp.sdc.be.tosca;
 
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DEFAULT;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.INPUTS;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.OPERATIONS;
+
 import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.gson.Gson;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Objects;
 import org.apache.commons.collections.MapUtils;
+import org.openecomp.sdc.be.datatypes.elements.InputDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
 import org.openecomp.sdc.be.model.Component;
@@ -27,30 +38,27 @@ import org.openecomp.sdc.be.model.ComponentInstance;
 import org.openecomp.sdc.be.model.DataTypeDefinition;
 import org.openecomp.sdc.be.model.InterfaceDefinition;
 import org.openecomp.sdc.be.model.Product;
-import org.openecomp.sdc.tosca.datatypes.ToscaFunctions;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.tosca.PropertyConvertor.PropertyType;
+import org.openecomp.sdc.be.tosca.model.ToscaInput;
 import org.openecomp.sdc.be.tosca.model.ToscaInterfaceDefinition;
 import org.openecomp.sdc.be.tosca.model.ToscaInterfaceNodeType;
 import org.openecomp.sdc.be.tosca.model.ToscaLifecycleOperationDefinition;
 import org.openecomp.sdc.be.tosca.model.ToscaNodeType;
 import org.openecomp.sdc.be.tosca.model.ToscaProperty;
 import org.openecomp.sdc.be.tosca.utils.OperationArtifactUtil;
+import org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum;
+import org.openecomp.sdc.tosca.datatypes.ToscaFunctions;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-
 @Service
 public class InterfacesOperationsConverter {
 
 
     private static final String DERIVED_FROM_STANDARD_INTERFACE = "tosca.interfaces.node.lifecycle.Standard";
     private static final String DERIVED_FROM_BASE_DEFAULT = "org.openecomp.interfaces.node.lifecycle.";
-    private static final String OPERATIONS_KEY = "operations";
 
-    private static final String DEFAULT = "default";
     private static final String DEFAULT_HAS_UNDERSCORE = "_default";
     private static final String DOT = ".";
     private static final String DEFAULTP = "defaultp";
@@ -58,10 +66,10 @@ public class InterfacesOperationsConverter {
     public static final String SELF = "SELF";
     private static final String LOCAL_INTERFACE_TYPE = "Local";
 
-    private PropertyConvertor propertyConvertor;
+    private final PropertyConvertor propertyConvertor;
 
     @Autowired
-    public InterfacesOperationsConverter(PropertyConvertor propertyConvertor) {
+    public InterfacesOperationsConverter(final PropertyConvertor propertyConvertor) {
         this.propertyConvertor = propertyConvertor;
     }
 
@@ -96,7 +104,7 @@ public class InterfacesOperationsConverter {
                 }
                 toscaInterfaceType.setOperations(toscaOperations);
                 Map<String, Object> interfacesAsMap = getObjectAsMap(toscaInterfaceType);
-                Map<String, Object> operationsMap = (Map<String, Object>) interfacesAsMap.remove(OPERATIONS_KEY);
+                Map<String, Object> operationsMap = (Map<String, Object>) interfacesAsMap.remove(OPERATIONS.getElementName());
                 interfacesAsMap.putAll(operationsMap);
 
                 toscaInterfaceTypes.put(getInterfaceType(component, LOCAL_INTERFACE_TYPE), interfacesAsMap);
@@ -134,12 +142,12 @@ public class InterfacesOperationsConverter {
         return getInterfacesMap(component, null, component.getInterfaces(), dataTypes, isAssociatedComponent, false);
     }
 
-    public Map<String, Object> getInterfacesMap(Component component,
-                                                       ComponentInstance componentInstance,
-                                                       Map<String, InterfaceDefinition> interfaces,
-                                                       Map<String, DataTypeDefinition> dataTypes,
-                                                       boolean isAssociatedComponent,
-                                                       boolean isServiceProxyInterface) {
+    public Map<String, Object> getInterfacesMap(final Component component,
+                                                final ComponentInstance componentInstance,
+                                                final Map<String, InterfaceDefinition> interfaces,
+                                                final Map<String, DataTypeDefinition> dataTypes,
+                                                final boolean isAssociatedComponent,
+                                                final boolean isServiceProxyInterface) {
         if(MapUtils.isEmpty(interfaces)) {
             return null;
         }
@@ -155,7 +163,7 @@ public class InterfacesOperationsConverter {
             }
             toscaInterfaceDefinition.setType(interfaceType);
             final Map<String, OperationDataDefinition> operations = interfaceDefinition.getOperations();
-            Map<String, Object> toscaOperations = new HashMap<>();
+            Map<String, Object> toscaOperationMap = new HashMap<>();
 
             String operationArtifactPath;
             for (Map.Entry<String, OperationDataDefinition> operationEntry : operations.entrySet()) {
@@ -169,12 +177,20 @@ public class InterfacesOperationsConverter {
                 toscaOperation.setDescription(operationEntry.getValue().getDescription());
                 fillToscaOperationInputs(operationEntry.getValue(), dataTypes, toscaOperation, isServiceProxyInterface);
 
-                toscaOperations.put(operationEntry.getValue().getName(), toscaOperation);
+                toscaOperationMap.put(operationEntry.getValue().getName(), toscaOperation);
+            }
+            toscaInterfaceDefinition.setOperations(toscaOperationMap);
+
+            final Map<String, Object> interfaceInputMap = createInterfaceInputMap(interfaceDefinition, dataTypes);
+            if (!interfaceInputMap.isEmpty()) {
+                toscaInterfaceDefinition.setInputs(interfaceInputMap);
             }
 
-            toscaInterfaceDefinition.setOperations(toscaOperations);
             Map<String, Object> interfaceDefAsMap = getObjectAsMap(toscaInterfaceDefinition);
-            Map<String, Object> operationsMap = (Map<String, Object>) interfaceDefAsMap.remove(OPERATIONS_KEY);
+            if (interfaceDefAsMap.containsKey(INPUTS.getElementName())) {
+                handleDefaults((Map<String, Object>) interfaceDefAsMap.get(INPUTS.getElementName()));
+            }
+            Map<String, Object> operationsMap = (Map<String, Object>) interfaceDefAsMap.remove(OPERATIONS.getElementName());
             if (isServiceProxyInterface) {
                 //Remove input type and copy default value directly into the proxy node template from the node type
                 handleServiceProxyOperationInputValue(operationsMap, interfaceType);
@@ -188,6 +204,22 @@ public class InterfacesOperationsConverter {
         return toscaInterfaceDefinitions;
     }
 
+    private Map<String, Object> createInterfaceInputMap(final InterfaceDefinition interfaceDefinition,
+                                                        final Map<String, DataTypeDefinition> allDataTypeMap) {
+        final Map<String, InputDataDefinition> inputMap = interfaceDefinition.getInputs();
+        if (MapUtils.isEmpty(inputMap)) {
+            return Collections.emptyMap();
+        }
+        final Map<String, Object> toscaInterfaceInputMap = new HashMap<>();
+        for (final Entry<String, InputDataDefinition> inputEntry : inputMap.entrySet()) {
+            final InputDataDefinition inputDataDefinition = inputEntry.getValue();
+            final ToscaProperty toscaProperty = propertyConvertor
+                .convertProperty(allDataTypeMap, new PropertyDefinition(inputDataDefinition), PropertyType.INPUT);
+            toscaInterfaceInputMap.put(inputEntry.getKey(), new ToscaInput(toscaProperty));
+        }
+        return toscaInterfaceInputMap;
+    }
+
     private static void handleServiceProxyOperationInputValue(Map<String, Object> operationsMap, String parentKey) {
         for (Map.Entry<String, Object> operationEntry : operationsMap.entrySet()) {
             final Object value = operationEntry.getValue();
@@ -223,7 +255,7 @@ public class InterfacesOperationsConverter {
      * ToscaExportHandler so, any string Map key named "defaultp" will have its named changed to "default"
      * @param operationsMap the map to update
      */
-    private static void handleDefaults(Map<String, Object> operationsMap) {
+    private void handleDefaults(Map<String, Object> operationsMap) {
         for (Map.Entry<String, Object> operationEntry : operationsMap.entrySet()) {
             final Object value = operationEntry.getValue();
             if (value instanceof Map) {
@@ -232,7 +264,7 @@ public class InterfacesOperationsConverter {
             final String key = operationEntry.getKey();
             if (key.equals(DEFAULTP)) {
                 Object removed = operationsMap.remove(key);
-                operationsMap.put(DEFAULT, removed);
+                operationsMap.put(ToscaTagNamesEnum.DEFAULT.getElementName(), removed);
             }
         }
     }
@@ -314,10 +346,9 @@ public class InterfacesOperationsConverter {
         Map<String, Object> objectAsMap =
                 obj instanceof Map ? (Map<String, Object>) obj : objectMapper.convertValue(obj, Map.class);
 
-        if (objectAsMap.containsKey(DEFAULT)) {
-            Object defaultValue = objectAsMap.get(DEFAULT);
-            objectAsMap.remove(DEFAULT);
-            objectAsMap.put(DEFAULT_HAS_UNDERSCORE, defaultValue);
+        final String defaultEntry = DEFAULT.getElementName();
+        if (objectAsMap.containsKey(defaultEntry)) {
+            objectAsMap.put(DEFAULT_HAS_UNDERSCORE, objectAsMap.remove(defaultEntry));
         }
         return objectAsMap;
     }
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/model/ToscaInterfaceDefinition.java b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/model/ToscaInterfaceDefinition.java
index 1d444e697a..2f4a3d8ac1 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/model/ToscaInterfaceDefinition.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/model/ToscaInterfaceDefinition.java
@@ -16,35 +16,20 @@
 package org.openecomp.sdc.be.tosca.model;
 
 import java.util.Map;
+import lombok.Getter;
+import lombok.Setter;
 
 /**
  * @author KATYR
  * @since March 26, 2018
  */
-
+@Setter
+@Getter
 public class ToscaInterfaceDefinition {
 
     private String type;
-    private Map<String, Object> operations; // ToscaLifecycleOperationDefinition <-> Object
-
-    public String getType() {
-        return type;
-    }
-
-    public void setType(String type) {
-        this.type = type;
-    }
-
-    public Map<String, Object> getOperations() {
-        return operations;
-    }
-
-//    public void setOperations(Map<String, Object> operations) {
-//        this.operations = operations;
-//    }
+    private Map<String, Object> operations;
+    private Map<String, Object> inputs;
 
-    public void setOperations(Map<String,Object> toscaOperations) {
-        this.operations = toscaOperations;
-    }
 }
 
diff --git a/catalog-be/src/main/resources/config/error-configuration.yaml b/catalog-be/src/main/resources/config/error-configuration.yaml
index 14b4ece4b0..96bfa245e3 100644
--- a/catalog-be/src/main/resources/config/error-configuration.yaml
+++ b/catalog-be/src/main/resources/config/error-configuration.yaml
@@ -2060,6 +2060,18 @@ errors:
       message: "Error: Failed to delete interface operation.",
       messageId: "SVC4702"
     }
+    #SVC4732
+    INTERFACE_UNKNOWN: {
+        code: 400,
+        message: "Error: The interface '%1' does not exists in the database.",
+        messageId: "SVC4732"
+    }
+    #SVC4733
+    INTERFACE_OPERATION_NOT_DEFINED: {
+        code: 400,
+        message: "Error: The operation '%1' does not exists in the interface '%2'.",
+        messageId: "SVC4733"
+    }
     #-----------SVC4692---------------------------
     RESOURCE_LIFECYCLE_STATE_NOT_VALID: {
         code: 400,
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/ResourceImportManagerTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/ResourceImportManagerTest.java
index b497253118..336b8ec940 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/ResourceImportManagerTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/ResourceImportManagerTest.java
@@ -22,7 +22,20 @@
 
 package org.openecomp.sdc.be.components;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.when;
+
 import fj.data.Either;
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.junit.Before;
 import org.junit.BeforeClass;
@@ -32,6 +45,7 @@ import org.mockito.stubbing.Answer;
 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
 import org.openecomp.sdc.be.components.impl.ImportUtils;
 import org.openecomp.sdc.be.components.impl.ImportUtilsTest;
+import org.openecomp.sdc.be.components.impl.InterfaceDefinitionHandler;
 import org.openecomp.sdc.be.components.impl.InterfaceOperationBusinessLogic;
 import org.openecomp.sdc.be.components.impl.ResourceBusinessLogic;
 import org.openecomp.sdc.be.components.impl.ResourceImportManager;
@@ -63,27 +77,15 @@ import org.openecomp.sdc.common.impl.FSConfigurationSource;
 import org.openecomp.sdc.exception.PolicyException;
 import org.openecomp.sdc.exception.ResponseFormat;
 
-import java.io.IOException;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.when;
-
 public class ResourceImportManagerTest {
 
-    private static ConfigurationManager configurationManager;
     static ResourceImportManager importManager;
     static AuditingManager auditingManager = Mockito.mock(AuditingManager.class);
     static ResponseFormatManager responseFormatManager = Mockito.mock(ResponseFormatManager.class);
     static ResourceBusinessLogic resourceBusinessLogic = Mockito.mock(ResourceBusinessLogic.class);
     static InterfaceOperationBusinessLogic interfaceOperationBusinessLogic = Mockito.mock(InterfaceOperationBusinessLogic.class);
+    static InterfaceDefinitionHandler interfaceDefinitionHandler =
+        new InterfaceDefinitionHandler(interfaceOperationBusinessLogic);
 
     static UserBusinessLogic userAdmin = Mockito.mock(UserBusinessLogic.class);
     static ToscaOperationFacade toscaOperationFacade =  Mockito.mock(ToscaOperationFacade.class);
@@ -93,17 +95,16 @@ public class ResourceImportManagerTest {
 
     @BeforeClass
     public static void beforeClass() {
-        importManager = new ResourceImportManager(componentsUtils, capabilityTypeOperation);
+        importManager = new ResourceImportManager(componentsUtils, capabilityTypeOperation, interfaceDefinitionHandler);
         importManager.setAuditingManager(auditingManager);
         when(toscaOperationFacade.getLatestByToscaResourceName(Mockito.anyString())).thenReturn(Either.left(null));
         importManager.setResponseFormatManager(responseFormatManager);
         importManager.setResourceBusinessLogic(resourceBusinessLogic);
-        importManager.setInterfaceOperationBusinessLogic(interfaceOperationBusinessLogic);
         importManager.setToscaOperationFacade(toscaOperationFacade);
 
         String appConfigDir = "src/test/resources/config/catalog-be";
         ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir);
-        configurationManager = new ConfigurationManager(configurationSource);
+        final ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
 
         Configuration configuration = new Configuration();
         configuration.setJanusGraphInMemoryGraph(true);
@@ -223,8 +224,9 @@ public class ResourceImportManagerTest {
         interfaceTypes.put("tosca.interfaces.node.lifecycle.standard", interfaceDefinition);
 		when(interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(interfaceTypes));
 
-        ImmutablePair<Resource, ActionStatus> createResource = importManager.importNormativeResource(jsonContent, resourceMD, user, true, true);
-        testSetInterfaceImplementation(createResource.left);
+        final ImmutablePair<Resource, ActionStatus> createResource = importManager
+            .importNormativeResource(jsonContent, resourceMD, user, true, true);
+        assertSetInterfaceImplementation(createResource.left);
     }
     
     @Test
@@ -342,12 +344,12 @@ public class ResourceImportManagerTest {
         assertTrue(properties.containsKey("volume_id"));
         propertyDefinition = properties.get("volume_id");
         assertEquals("string", propertyDefinition.getType());
-        assertTrue(!propertyDefinition.isRequired());
+        assertFalse(propertyDefinition.isRequired());
 
         assertTrue(properties.containsKey("snapshot_id"));
         propertyDefinition = properties.get("snapshot_id");
         assertEquals("string", propertyDefinition.getType());
-        assertTrue(!propertyDefinition.isRequired());
+        assertFalse(propertyDefinition.isRequired());
 
     }
 
@@ -398,20 +400,19 @@ public class ResourceImportManagerTest {
 
     }
     
-    private void testSetInterfaceImplementation(Resource resource) {
-    	Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
+    private void assertSetInterfaceImplementation(final Resource resource) {
+        final Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
         assertEquals(1, interfaces.size());
         assertTrue(interfaces.containsKey("Standard"));
-        
-        InterfaceDefinition interfaceDefinition = interfaces.get("Standard");
+
+        final InterfaceDefinition interfaceDefinition = interfaces.get("Standard");
         assertEquals("tosca.interfaces.node.lifecycle.Standard", interfaceDefinition.getType());
         assertEquals("tosca.interfaces.node.lifecycle.standard", interfaceDefinition.getUniqueId());
-        Map<String, OperationDataDefinition> operations = interfaceDefinition.getOperations();
+        final Map<String, OperationDataDefinition> operations = interfaceDefinition.getOperations();
         assertEquals(1, operations.size());
 
-        OperationDataDefinition operation = operations.get("configure");
+        final OperationDataDefinition operation = operations.get("configure");
         assertEquals("'camunda/vnfConfigure'", operation.getImplementation().getArtifactName());
-
     }
 
     private void testSetDerivedFrom(Resource resource) {
@@ -421,19 +422,12 @@ public class ResourceImportManagerTest {
     }
 
     private void testSetMetaDataFromJson(Resource resource, UploadResourceInfo resourceMD) {
-
-        // assertTrue( resource.getCategory().equals(resourceMD.getCategory())
-        // );
         assertEquals(resource.getDescription(), resourceMD.getDescription());
         assertEquals(resource.getIcon(), resourceMD.getResourceIconPath());
         assertEquals(resource.getName(), resourceMD.getName());
         assertEquals(resource.getResourceVendorModelNumber(), resourceMD.getResourceVendorModelNumber());
         assertEquals(resource.getContactId(), resourceMD.getContactId());
         assertEquals(resource.getCreatorUserId(), resourceMD.getContactId());
-
-        // assertTrue( resource.isAbstract() ==
-        // Constants.ABSTRACT_CATEGORY.equals(resourceMD.getCategory()));
-
         assertEquals(resourceMD.getTags().size(), resource.getTags().size());
         for (String tag : resource.getTags()) {
             assertTrue(resourceMD.getTags().contains(tag));
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ImportUtilsTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ImportUtilsTest.java
index 87875d8f20..9cd095b5b5 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ImportUtilsTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ImportUtilsTest.java
@@ -324,7 +324,7 @@ public class ImportUtilsTest {
         PropertyDefinition property = properties.get("service_type");
         assertTrue(property.getConstraints()!= null && property.getConstraints().size() == 1);
         assertTrue(property.getConstraints().get(0) instanceof ValidValuesConstraint);
-        assertTrue(((ValidValuesConstraint) property.getConstraints().get(0)).getValidValues() != null);
+        assertNotNull(((ValidValuesConstraint) property.getConstraints().get(0)).getValidValues());
         List<String> validValues = ((ValidValuesConstraint) property.getConstraints().get(0)).getValidValues();
         assertTrue(validValues.containsAll(Lists.newArrayList("firewall", "analyzer", "source-nat", "loadbalancer")));
 
@@ -334,7 +334,7 @@ public class ImportUtilsTest {
         PropertyDefinition innerProperty = new PropertyDefinition(property.getSchema().getProperty());
         List<PropertyConstraint> innerConstraints = innerProperty.getConstraints();
         assertTrue(innerConstraints.get(0) instanceof ValidValuesConstraint);
-        assertTrue(((ValidValuesConstraint) innerConstraints.get(0)).getValidValues() != null);
+        assertNotNull(((ValidValuesConstraint) innerConstraints.get(0)).getValidValues());
         validValues = ((ValidValuesConstraint) innerConstraints.get(0)).getValidValues();
         assertTrue(validValues.containsAll(Lists.newArrayList("management", "left", "right", "other")));
     }
@@ -352,6 +352,10 @@ public class ImportUtilsTest {
         Map<String, Map<String, Object>> expectedProperties = getElements(toscaJson, TypeUtils.ToscaTagNamesEnum.INPUTS);
         compareProperties(expectedProperties, actualInputs.left().value());
 
+        actualInputs = ImportUtils.getInputs(toscaJson);
+        assertTrue(actualInputs.isLeft());
+        expectedProperties = getElements(toscaJson, TypeUtils.ToscaTagNamesEnum.INPUTS);
+        compareProperties(expectedProperties, actualInputs.left().value());
     }
 
     private void compareAttributes(Map<String, Map<String, Object>> expected, Map<String, AttributeDataDefinition> actual) {
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InterfaceDefinitionHandlerTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InterfaceDefinitionHandlerTest.java
new file mode 100644
index 0000000000..f819eceb43
--- /dev/null
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InterfaceDefinitionHandlerTest.java
@@ -0,0 +1,174 @@
+/*
+ * ============LICENSE_START=======================================================
+ *  Copyright (C) 2020 Nordix Foundation
+ *  ================================================================================
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *  SPDX-License-Identifier: Apache-2.0
+ *  ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.be.components.impl;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.aMapWithSize;
+import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.hasItems;
+import static org.hamcrest.Matchers.hasSize;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+import static org.mockito.Mockito.when;
+
+import fj.data.Either;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import org.apache.commons.collections.MapUtils;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.InputDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
+import org.openecomp.sdc.be.model.InterfaceDefinition;
+import org.yaml.snakeyaml.Yaml;
+
+@ExtendWith(MockitoExtension.class)
+class InterfaceDefinitionHandlerTest {
+
+    @Mock
+    private InterfaceOperationBusinessLogic interfaceOperationBusinessLogic;
+    private InterfaceDefinitionHandler interfaceDefinitionHandler;
+    private InterfaceDefinition interfaceLifecyleStandard;
+    private static final Path TEST_RESOURCE_PATH = Paths.get("src/test/resources/interfaceDefinition");
+    private static final String CREATE_OPERATION = "create";
+    private static final String DELETE_OPERATION = "delete";
+    private static final String START_OPERATION = "start";
+    private static final String STOP_OPERATION = "stop";
+    private static final String INTERFACE_TYPE = "tosca.interfaces.node.lifecycle.Standard";
+
+    @BeforeEach
+    void setUp() {
+        interfaceDefinitionHandler = new InterfaceDefinitionHandler(interfaceOperationBusinessLogic);
+        mockAllInterfacesLifecycle();
+    }
+
+    private void mockAllInterfacesLifecycle() {
+        final Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>();
+        interfaceLifecyleStandard = new InterfaceDefinition();
+        interfaceLifecyleStandard.setType(INTERFACE_TYPE);
+        final Map<String, OperationDataDefinition> operations = new HashMap<>();
+        operations.put(CREATE_OPERATION, new OperationDataDefinition());
+        operations.put(START_OPERATION, new OperationDataDefinition());
+        operations.put(STOP_OPERATION, new OperationDataDefinition());
+        operations.put(DELETE_OPERATION, new OperationDataDefinition());
+        interfaceLifecyleStandard.setOperations(operations);
+        interfaceTypes.put(INTERFACE_TYPE, interfaceLifecyleStandard);
+        when(interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(interfaceTypes));
+    }
+
+    @Test
+    void testCreateWithLegacyOperationDeclarationSuccess() throws FileNotFoundException {
+        final Map<String, Object> load = loadYaml(Paths.get("interfaceDefinition-legacy.yaml"));
+        final InterfaceDefinition actualInterfaceDefinition = interfaceDefinitionHandler.create(load);
+        assertInterfaceDefinition(actualInterfaceDefinition);
+    }
+
+    @Test
+    void testCreateWithOperationSuccess() throws FileNotFoundException {
+        final Map<String, Object> load = loadYaml(Paths.get("interfaceDefinition-tosca1.3.yaml"));
+        final InterfaceDefinition actualInterfaceDefinition = interfaceDefinitionHandler.create(load);
+        assertInterfaceDefinition(actualInterfaceDefinition);
+    }
+
+    private void assertInterfaceDefinition(final InterfaceDefinition actualInterfaceDefinition) {
+        interfaceLifecyleStandard.getOperations().keySet().forEach(operation ->
+            assertTrue(actualInterfaceDefinition.hasOperation(operation)));
+        assertThat("Interface type should be as expected", actualInterfaceDefinition.getType(),
+            equalTo(actualInterfaceDefinition.getType()));
+        assertThat("Interface should contain 2 inputs", actualInterfaceDefinition.getInputs(), aMapWithSize(2));
+        assertThat("Interface inputs should be as expected", actualInterfaceDefinition.getInputs().keySet(),
+            containsInAnyOrder("stringInput", "actionInput"));
+
+        final InputDataDefinition stringInput = actualInterfaceDefinition.getInputs().get("stringInput");
+        assertInput("string", "stringInput description", true, "defaultValue", "aStatus", stringInput);
+        final InputDataDefinition actionInput = actualInterfaceDefinition.getInputs().get("actionInput");
+        assertInput("org.openecomp.resource.datatypes.Action", null, false, null, null, actionInput);
+
+        final OperationDataDefinition createOperation = actualInterfaceDefinition.getOperations().get(CREATE_OPERATION);
+        assertOperation("'camunda/serviceSelect'", createOperation);
+
+        final OperationDataDefinition deleteOperation = actualInterfaceDefinition.getOperations().get(DELETE_OPERATION);
+        assertOperation("'camunda/serviceDeselect'", deleteOperation);
+
+        final Map<String, String> expectedInputMap = new HashMap<>();
+        expectedInputMap.put("action", "org.openecomp.resource.datatypes.Action");
+        final OperationDataDefinition startOperation = actualInterfaceDefinition.getOperations().get(START_OPERATION);
+        assertOperation("'camunda/executeAction'", expectedInputMap, startOperation);
+        final OperationDataDefinition stopOperation = actualInterfaceDefinition.getOperations().get(STOP_OPERATION);
+        assertOperation("'camunda/executeAction'", expectedInputMap, stopOperation);
+    }
+
+    private void assertOperation(final String implementation, final OperationDataDefinition actualOperation) {
+        assertOperation(implementation, Collections.emptyMap(), actualOperation);
+    }
+
+    private void assertOperation(final String implementation, final Map<String, String> inputNameTypeMap,
+                                 final OperationDataDefinition actualOperation) {
+        final ArtifactDataDefinition artifactDefinition = actualOperation.getImplementation();
+        assertThat("Implementation should be as expected", artifactDefinition.getArtifactName(), equalTo(implementation));
+        final ListDataDefinition<OperationInputDefinition> inputListDataDef = actualOperation.getInputs();
+        if (inputListDataDef == null) {
+            if (MapUtils.isNotEmpty(inputNameTypeMap)) {
+                final String expectedInputNames = String.join(",", inputNameTypeMap.keySet());
+                fail(String.format("No inputs were found, but some inputs are expected: %s", expectedInputNames));
+            }
+            return;
+        }
+
+        final String msgFormat = "Operation should have %s";
+        final List<OperationInputDefinition> inputList = inputListDataDef.getListToscaDataDefinition();
+        assertThat(String.format(msgFormat, "the expected quantity of inputs"), inputList, hasSize(inputNameTypeMap.size()));
+
+        final List<String> inputNames = inputList.stream()
+            .map(OperationInputDefinition::getName).collect(Collectors.toList());
+
+        assertThat(String.format(msgFormat, "the expected inputs"), inputNames,
+            hasItems(inputNameTypeMap.keySet().toArray(new String[0])));
+    }
+
+    private void assertInput(final String type, final String description, final Boolean required,
+                             final String defaultValue, final String status, final InputDataDefinition actualInput) {
+        assertThat("Input type should be as expected", type, equalTo(actualInput.getType()));
+        assertThat("Input description should be as expected", description, equalTo(actualInput.getDescription()));
+        assertThat("Input required should be as expected", required, equalTo(required != null && required));
+        assertThat("Input default should be as expected", defaultValue, equalTo(actualInput.getDefaultValue()));
+        assertThat("Input status should be as expected", status, equalTo(actualInput.getStatus()));
+    }
+
+    private Map<String, Object> loadYaml(final Path filePathFromResource) throws FileNotFoundException {
+        final Path filePath = Paths.get(TEST_RESOURCE_PATH.toString(), filePathFromResource.toString());
+        final FileInputStream fileInputStream = new FileInputStream(filePath.toString());
+        return (Map<String, Object>) new Yaml().load(fileInputStream);
+    }
+}
\ No newline at end of file
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsConverterTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/InterfacesOperationsConverterTest.java
index 93a45ad20f..0281317b89 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsConverterTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/InterfacesOperationsConverterTest.java
@@ -1,24 +1,42 @@
 /*
- * Copyright © 2016-2018 European Support Limited
+ * ============LICENSE_START=======================================================
+ *  Copyright (C) 2020 Nordix Foundation
+ *  ================================================================================
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
  *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ *  SPDX-License-Identifier: Apache-2.0
+ *  ============LICENSE_END=========================================================
  */
 
-package org.openecomp.sdc.be.tosca.utils;
-
-import static org.mockito.Mockito.mock;
+package org.openecomp.sdc.be.tosca;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.allOf;
+import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
 import static org.openecomp.sdc.be.tosca.InterfacesOperationsConverter.SELF;
 import static org.openecomp.sdc.be.tosca.InterfacesOperationsConverter.addInterfaceTypeElement;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DEFAULT;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DESCRIPTION;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.INPUTS;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.INTERFACES;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.NODE_TYPES;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.REQUIRED;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.TYPE;
 
 import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.databind.ObjectMapper;
@@ -28,23 +46,23 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Objects;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 import org.apache.commons.collections4.MapUtils;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.onap.sdc.tosca.services.YamlUtil;
 import org.openecomp.sdc.be.DummyConfigurationManager;
-import org.openecomp.sdc.be.config.Configuration;
 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.InputDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
 import org.openecomp.sdc.be.datatypes.elements.OperationOutputDefinition;
+import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
 import org.openecomp.sdc.be.model.Component;
 import org.openecomp.sdc.be.model.DataTypeDefinition;
 import org.openecomp.sdc.be.model.InputDefinition;
@@ -52,44 +70,40 @@ import org.openecomp.sdc.be.model.InterfaceDefinition;
 import org.openecomp.sdc.be.model.Resource;
 import org.openecomp.sdc.be.model.Service;
 import org.openecomp.sdc.be.model.ServiceMetadataDefinition;
-import org.openecomp.sdc.be.tosca.InterfacesOperationsConverter;
-import org.openecomp.sdc.be.tosca.PropertyConvertor;
-import org.openecomp.sdc.be.tosca.ToscaExportHandler;
-import org.openecomp.sdc.be.tosca.ToscaRepresentation;
 import org.openecomp.sdc.be.tosca.model.ToscaNodeType;
 import org.openecomp.sdc.be.tosca.model.ToscaTemplate;
 import org.openecomp.sdc.common.util.YamlToObjectConverter;
 import org.openecomp.sdc.tosca.datatypes.ToscaFunctions;
+import org.yaml.snakeyaml.Yaml;
 
-@RunWith(MockitoJUnitRunner.class)
-public class InterfacesOperationsConverterTest {
+class InterfacesOperationsConverterTest {
 
     private static final String MAPPED_PROPERTY_NAME = "mapped_property";
     private static final String INPUT_NAME_PREFIX = "input_";
     private static final String OUTPUT_NAME_PREFIX = "output_";
     private static final String NODE_TYPE_NAME = "test";
-    private String[] inputTypes = {"string", "integer", "float", "boolean"};
+    private final String[] inputTypes = {"string", "integer", "float", "boolean"};
     private static ObjectMapper mapper;
-    private Configuration.EnvironmentContext environmentContext = mock(Configuration.EnvironmentContext.class);
-    DummyConfigurationManager dummyConfigurationManager = new DummyConfigurationManager();
     private static final Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 
     private InterfacesOperationsConverter interfacesOperationsConverter;
 
-    @BeforeClass
+    @BeforeAll
     public static void setUp() {
+        //initialize the static configuration manager
+        new DummyConfigurationManager();
         mapper = new ObjectMapper();
         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
     }
 
-    @Before
+    @BeforeEach
     public void setUpBeforeTest() {
         interfacesOperationsConverter =
                 new InterfacesOperationsConverter(new PropertyConvertor());
     }
 
     @Test
-    public void addInterfaceTypeElementToResource() {
+    void addInterfaceTypeElementToResource() {
         Component component = new Resource();
         component.setNormalizedName("normalizedComponentName");
         component.setComponentMetadataDefinition(new ServiceMetadataDefinition());
@@ -110,14 +124,14 @@ public class InterfacesOperationsConverterTest {
         template.setInterface_types(interfaceTypeElement);
         final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template);
 
-        Assert.assertTrue(all(
+        assertTrue(all(
             containsAll("NodeTypeName"),
             containsNone("operations")
         ).apply(new String(toscaRepresentation.getMainYaml())));
     }
 
     @Test
-    public void addInterfaceTypeElementToService() {
+    void addInterfaceTypeElementToService() {
         Component component = new Service();
         component.setNormalizedName("normalizedServiceComponentName");
         component.setComponentMetadataDefinition(new ServiceMetadataDefinition());
@@ -138,14 +152,14 @@ public class InterfacesOperationsConverterTest {
         template.setInterface_types(interfaceTypeElement);
         final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template);
 
-        Assert.assertTrue(all(
+        assertTrue(all(
             containsAll("NodeTypeName"),
             containsNone("operations")
         ).apply(new String(toscaRepresentation.getMainYaml())));
     }
 
     @Test
-    public void addInterfaceDefinitionElementToResource() {
+    void addInterfaceDefinitionElementToResource() {
         Component component = new Resource();
         component.setNormalizedName("normalizedComponentName");
         InterfaceDefinition addedInterface = new InterfaceDefinition();
@@ -167,7 +181,7 @@ public class InterfacesOperationsConverterTest {
         final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template);
 
         String mainYaml = new String(toscaRepresentation.getMainYaml());
-        Assert.assertTrue(all(
+        assertTrue(all(
             containsAll("resourceName:", "inputs:", "has description", MAPPED_PROPERTY_NAME, "com.some.resource.or.other.resourceName"),
             containsNone("operations", "defaultp")
         ).apply(mainYaml));
@@ -176,7 +190,7 @@ public class InterfacesOperationsConverterTest {
     }
 
     @Test
-    public void addInterfaceDefinitionElementToService() {
+    void addInterfaceDefinitionElementToService() {
         Component component = new Service();
         component.setNormalizedName("normalizedServiceComponentName");
         InterfaceDefinition addedInterface = new InterfaceDefinition();
@@ -196,7 +210,7 @@ public class InterfacesOperationsConverterTest {
         template.setNode_types(nodeTypes);
         final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template);
         String mainYaml = new String(toscaRepresentation.getMainYaml());
-        Assert.assertTrue(all(
+        assertTrue(all(
             containsAll("serviceName", "inputs:", "has description", MAPPED_PROPERTY_NAME, "com.some.service.or.other.serviceName"),
             containsNone("operations", "defaultp")
         ).apply(mainYaml));
@@ -205,7 +219,7 @@ public class InterfacesOperationsConverterTest {
 
 
     @Test
-    public void testGetInterfaceAsMapServiceProxy() {
+    void testGetInterfaceAsMapServiceProxy() {
         Component component = new Resource();
         component.setNormalizedName("normalizedComponentName");
         InterfaceDefinition addedInterface = new InterfaceDefinition();
@@ -227,7 +241,7 @@ public class InterfacesOperationsConverterTest {
         final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template);
 
         String mainYaml = new String(toscaRepresentation.getMainYaml());
-        Assert.assertTrue(all(
+        assertTrue(all(
             containsAll("resourceName:", "inputs:", "has description", MAPPED_PROPERTY_NAME, "com.some.resource.or.other.resourceName"),
             containsNone("operations", "defaultp")
         ).apply(mainYaml));
@@ -235,7 +249,7 @@ public class InterfacesOperationsConverterTest {
     }
 
     @Test
-    public void addInterfaceDefinitionElement_noInputs() {
+    void addInterfaceDefinitionElement_noInputs() {
         Component component = new Resource();
         component.setNormalizedName("normalizedComponentName");
         InterfaceDefinition addedInterface = new InterfaceDefinition();
@@ -255,14 +269,14 @@ public class InterfacesOperationsConverterTest {
         template.setNode_types(nodeTypes);
         final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template);
 
-        Assert.assertTrue(all(
+        assertTrue(all(
             containsAll("resourceNameNoInputs", "has description", "com.some.resource.or.other.resourceName"),
             containsNone("operations", INPUT_NAME_PREFIX, "defaultp")
         ).apply(new String(toscaRepresentation.getMainYaml())));
     }
 
     @Test
-    public void addInterfaceDefinitionElementInputMappedToOtherOperationOutput() {
+    void addInterfaceDefinitionElementInputMappedToOtherOperationOutput() {
         String addedInterfaceType = "com.some.resource.or.other.resourceNameInputMappedToOutput";
         Component component = new Resource();
         component.setNormalizedName("normalizedComponentName");
@@ -289,7 +303,7 @@ public class InterfacesOperationsConverterTest {
         template.setNode_types(nodeTypes);
         final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template);
         String mainYaml = new String(toscaRepresentation.getMainYaml());
-        Assert.assertTrue(all(
+        assertTrue(all(
             containsAll("resourceNameInputMappedToOutput:", "inputs:"),
             containsNone("operations")
         ).apply(mainYaml));
@@ -297,7 +311,7 @@ public class InterfacesOperationsConverterTest {
     }
 
     @Test
-    public void addInterfaceDefinitionElementInputMappedToOtherOperationOutputFromOtherInterface() {
+    void addInterfaceDefinitionElementInputMappedToOtherOperationOutputFromOtherInterface() {
         String addedInterfaceType = "com.some.resource.or.other.resourceNameInputMappedToOutput";
         Component component = new Resource();
         component.setNormalizedName("normalizedComponentName");
@@ -339,13 +353,83 @@ public class InterfacesOperationsConverterTest {
         final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template);
 
         String mainYaml = new String(toscaRepresentation.getMainYaml());
-        Assert.assertTrue(all(
+        assertTrue(all(
             containsAll("resourceNameInputMappedToOutput:", "inputs:"),
             containsNone("operations")
         ).apply(mainYaml));
         validateOperationInputs(mainYaml, 2, "name_for_op_1");
     }
 
+    @Test
+    void interfaceWithInputsToscaExportTest() {
+        final Component component = new Service();
+        final InterfaceDefinition aInterfaceWithInput = new InterfaceDefinition();
+        final String interfaceName = "myInterfaceName";
+        final String interfaceType = "my.type." + interfaceName;
+        aInterfaceWithInput.setType(interfaceType);
+        final String input1Name = "input1";
+        final InputDataDefinition input1 = createInput("string", "input1 description", false, "input1 value");
+        final String input2Name = "input2";
+        final InputDataDefinition input2 = createInput("string", "input2 description", true, "input2 value");
+        final Map<String, InputDataDefinition> inputMap = new HashMap<>();
+        inputMap.put(input1Name, input1);
+        inputMap.put(input2Name, input2);
+        aInterfaceWithInput.setInputs(inputMap);
+        component.setInterfaces(new HashMap<>());
+        component.getInterfaces().put(interfaceName, aInterfaceWithInput);
+        final ToscaNodeType nodeType = new ToscaNodeType();
+        interfacesOperationsConverter.addInterfaceDefinitionElement(component, nodeType, dataTypes, false);
+        final ToscaExportHandler handler = new ToscaExportHandler(null, null, null, null, null, null, null, null,
+            interfacesOperationsConverter);
+        final ToscaTemplate template = new ToscaTemplate("testService");
+        final Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
+        nodeTypes.put(NODE_TYPE_NAME, nodeType);
+        template.setNode_types(nodeTypes);
+        final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template);
+        final String toscaTemplateYaml = new String(toscaRepresentation.getMainYaml());
+        assertThat(toscaTemplateYaml, allOf(containsString(INPUTS.getElementName() + ":"), containsString(input1Name), containsString(interfaceName)));
+        validateInterfaceInputs(toscaTemplateYaml, interfaceName, inputMap);
+    }
+
+    private void validateInterfaceInputs(final String yaml, final String interfaceName, final Map<String, InputDataDefinition> expectedInputMap) {
+        String fixedMainYaml = yaml;
+        final String nullString = "null";
+        if (fixedMainYaml.startsWith(nullString)) {
+            fixedMainYaml = yaml.substring(nullString.length());
+        }
+        if (fixedMainYaml.endsWith(nullString)) {
+            fixedMainYaml = fixedMainYaml.substring(0, fixedMainYaml.length() - nullString.length());
+        }
+        final Map<String, Object> yamlMap = (Map<String, Object>) new Yaml().load(fixedMainYaml);
+        final Map<String, Object> nodeTypesMap = (Map<String, Object>) yamlMap.get(NODE_TYPES.getElementName());
+        final Map<String, Object> node = (Map<String, Object>) nodeTypesMap.get(NODE_TYPE_NAME);
+        final Map<String, Object> interfacesMap = (Map<String, Object>) node.get(INTERFACES.getElementName());
+        final Map<String, Object> interface1 = (Map<String, Object>) interfacesMap.get(interfaceName);
+        final Map<String, Object> actualInputsMap = (Map<String, Object>) interface1.get(INPUTS.getElementName());
+        assertThat(actualInputsMap.keySet(), containsInAnyOrder(expectedInputMap.keySet().toArray()));
+        expectedInputMap.forEach((inputName, inputDataDefinition) -> {
+            final Map<String, Object> actualInput = (Map<String, Object>) actualInputsMap.get(inputName);
+            compareInputYaml(inputName, actualInput, inputDataDefinition);
+        });
+    }
+
+    private void compareInputYaml(final String inputName, final Map<String, Object> actualInput,
+                                  final InputDataDefinition expectedInput) {
+        final String msgFormat = "%s should be equal in input %s";
+        String field = TYPE.getElementName();
+        assertThat(String.format(msgFormat, field, inputName),
+            actualInput.get(field), equalTo(expectedInput.getType()));
+        field = DESCRIPTION.getElementName();
+        assertThat(String.format(msgFormat, field, inputName),
+            actualInput.get(field), equalTo(expectedInput.getDescription()));
+        field = REQUIRED.getElementName();
+        assertThat(String.format(msgFormat, field, inputName),
+            actualInput.get(field), equalTo(expectedInput.getRequired()));
+        field = DEFAULT.getElementName();
+        assertThat(String.format(msgFormat, field, inputName),
+            actualInput.get(field), equalTo(expectedInput.getDefaultValue()));
+    }
+
     @FunctionalInterface
     interface MainYamlAssertion extends Function<String, Boolean> {}
 
@@ -383,6 +467,24 @@ public class InterfacesOperationsConverterTest {
         }
     }
 
+    private InputDataDefinition createInput(final String type, final String description, final Boolean isRequired,
+                                            final String defaultValue) {
+        final PropertyDataDefinition propertyDataDefinition = new PropertyDataDefinition();
+        if (type != null) {
+            propertyDataDefinition.setType(type);
+        }
+        if (description != null) {
+            propertyDataDefinition.setDescription(description);
+        }
+        if (defaultValue != null) {
+            propertyDataDefinition.setDefaultValue(defaultValue);
+        }
+        if (isRequired != null) {
+            propertyDataDefinition.setRequired(isRequired);
+        }
+        return new InputDataDefinition(propertyDataDefinition);
+    }
+
     private ListDataDefinition<OperationInputDefinition> createInputs(Component component, int numOfInputs) {
         ListDataDefinition<OperationInputDefinition> operationInputDefinitionList = new ListDataDefinition<>();
         for (int i = 0; i < numOfInputs; i++) {
@@ -458,7 +560,11 @@ public class InterfacesOperationsConverterTest {
         Map<String, Object> interfaces = toscaNodeType.getInterfaces();
         for (Map.Entry<String, Object> interfaceEntry : interfaces.entrySet()) {
             Map<String, Object> interfaceDefinition = mapper.convertValue(interfaceEntry.getValue(), Map.class);
-            for (Map.Entry<String, Object> operationEntry : interfaceDefinition.entrySet()) {
+            final Map<String, Object> operationsMap = interfaceDefinition.entrySet().stream()
+                .filter(entry -> !INPUTS.getElementName().equals(entry.getKey()) &&
+                    !TYPE.getElementName().equals(entry.getKey()))
+                .collect(Collectors.toMap(Entry::getKey, Entry::getValue));
+            for (Map.Entry<String, Object> operationEntry : operationsMap.entrySet()) {
                 Object operationVal = operationEntry.getValue();
                 if (operationVal instanceof Map) {
                     //Since the inputs are mapped to output operations from only first interface so using that name
@@ -475,9 +581,9 @@ public class InterfacesOperationsConverterTest {
         for (Map.Entry<String, Object> inputEntry : inputs.entrySet()) {
             String[] inputNameSplit = inputEntry.getKey().split("_");
             Map<String, Object> inputValueObject = (Map<String, Object>) inputEntry.getValue();
-            Assert.assertEquals(inputNameSplit[1], inputValueObject.get("type"));
+            assertEquals(inputNameSplit[1], inputValueObject.get("type"));
             Boolean expectedIsRequired = Integer.parseInt(inputNameSplit[2]) % 2 == 0;
-            Assert.assertEquals(expectedIsRequired, inputValueObject.get("required"));
+            assertEquals(expectedIsRequired, inputValueObject.get("required"));
             validateOperationInputDefinitionDefaultValue(interfaceType, operationName, inputNameSplit[1],
                     Integer.parseInt(inputNameSplit[2]), inputValueObject);
         }
@@ -491,19 +597,19 @@ public class InterfacesOperationsConverterTest {
         if(mappedInputValue.containsKey(ToscaFunctions.GET_PROPERTY.getFunctionName())) {
             String mappedPropertyValue = MAPPED_PROPERTY_NAME + index;
             List<String> mappedPropertyDefaultValue = (List<String>) mappedInputValue.get(ToscaFunctions.GET_PROPERTY.getFunctionName());
-            Assert.assertEquals(2, mappedPropertyDefaultValue.size());
-            Assert.assertTrue(mappedPropertyDefaultValue.contains(SELF));
-            Assert.assertTrue(mappedPropertyDefaultValue.contains(mappedPropertyValue));
+            assertEquals(2, mappedPropertyDefaultValue.size());
+            assertTrue(mappedPropertyDefaultValue.contains(SELF));
+            assertTrue(mappedPropertyDefaultValue.contains(mappedPropertyValue));
         } else if(mappedInputValue.containsKey(ToscaFunctions.GET_OPERATION_OUTPUT.getFunctionName())) {
             List<String> mappedPropertyDefaultValue = (List<String>) mappedInputValue.get(ToscaFunctions.GET_OPERATION_OUTPUT.getFunctionName());
-            Assert.assertEquals(4, mappedPropertyDefaultValue.size());
+            assertEquals(4, mappedPropertyDefaultValue.size());
             String mappedPropertyValue = OUTPUT_NAME_PREFIX + inputType + "_" + index;
-            Assert.assertTrue(mappedPropertyDefaultValue.contains(SELF));
-            Assert.assertTrue(mappedPropertyDefaultValue.contains(interfaceType));
-            Assert.assertTrue(mappedPropertyDefaultValue.contains(operationName));
-            Assert.assertTrue(mappedPropertyDefaultValue.contains(mappedPropertyValue));
+            assertTrue(mappedPropertyDefaultValue.contains(SELF));
+            assertTrue(mappedPropertyDefaultValue.contains(interfaceType));
+            assertTrue(mappedPropertyDefaultValue.contains(operationName));
+            assertTrue(mappedPropertyDefaultValue.contains(mappedPropertyValue));
         } else {
-            Assert.fail("Invalid Tosca function in default value. Allowed values: "+ ToscaFunctions.GET_PROPERTY.getFunctionName() +
+            fail("Invalid Tosca function in default value. Allowed values: "+ ToscaFunctions.GET_PROPERTY.getFunctionName() +
                     "/"+ ToscaFunctions.GET_OPERATION_OUTPUT.getFunctionName());
         }
     }
@@ -522,9 +628,9 @@ public class InterfacesOperationsConverterTest {
                     Map<String, Object> operationInputs = (Map<String, Object>) operation.get("inputs");
                     for (Object inputValue : operationInputs.values()) {
                         Map<String, Object> inputValueAsMap = (Map<String, Object>) inputValue;
-                        Assert.assertFalse(inputValueAsMap.keySet().contains("type"));
-                        Assert.assertFalse(inputValueAsMap.keySet().contains("required"));
-                        Assert.assertFalse(inputValueAsMap.keySet().contains("default"));
+                        assertFalse(inputValueAsMap.keySet().contains("type"));
+                        assertFalse(inputValueAsMap.keySet().contains("required"));
+                        assertFalse(inputValueAsMap.keySet().contains("default"));
                     }
                 }
             }
@@ -532,7 +638,7 @@ public class InterfacesOperationsConverterTest {
     }
 
     @Test
-    public void testAddInterfaceTypeElementGetCorrectLocalInterfaceName() {
+    void testAddInterfaceTypeElementGetCorrectLocalInterfaceName() {
         Service service = new Service();
         service.setComponentMetadataDefinition(new ServiceMetadataDefinition());
         service.getComponentMetadataDefinition().getMetadataDataDefinition().setName("LocalInterface");
@@ -542,12 +648,12 @@ public class InterfacesOperationsConverterTest {
         Map<String, Object> resultMap = InterfacesOperationsConverter.addInterfaceTypeElement(service,
                 Collections.singletonList("org.openecomp.interfaces.node.lifecycle.Standard"));
 
-        Assert.assertTrue(MapUtils.isNotEmpty(resultMap)
+        assertTrue(MapUtils.isNotEmpty(resultMap)
                 && resultMap.containsKey("org.openecomp.interfaces.node.lifecycle.LocalInterface"));
     }
 
     @Test
-    public void testAddInterfaceTypeElementNoTypeChangeIfNotLocal() {
+    void testAddInterfaceTypeElementNoTypeChangeIfNotLocal() {
         Service service = new Service();
         service.setComponentMetadataDefinition(new ServiceMetadataDefinition());
         service.getComponentMetadataDefinition().getMetadataDataDefinition().setName("LocalInterface");
@@ -557,7 +663,7 @@ public class InterfacesOperationsConverterTest {
         Map<String, Object> resultMap = interfacesOperationsConverter.getInterfacesMap(service, null,
                 service.getInterfaces(), null, false, false);
 
-        Assert.assertTrue(MapUtils.isNotEmpty(resultMap)
+        assertTrue(MapUtils.isNotEmpty(resultMap)
                 && resultMap.containsKey("NotLocal"));
     }
 }
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/model/ToscaInterfaceDefinitionTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/model/ToscaInterfaceDefinitionTest.java
deleted file mode 100644
index b922d0d60d..0000000000
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/model/ToscaInterfaceDefinitionTest.java
+++ /dev/null
@@ -1,72 +0,0 @@
-/*-
- * ============LICENSE_START=======================================================
- * SDC
- * ================================================================================
- * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-
-package org.openecomp.sdc.be.tosca.model;
-
-import org.junit.Test;
-
-import java.util.Map;
-
-public class ToscaInterfaceDefinitionTest {
-
-	private ToscaInterfaceDefinition createTestSubject() {
-		return new ToscaInterfaceDefinition();
-	}
-
-	@Test
-	public void testGetType() throws Exception {
-		ToscaInterfaceDefinition testSubject;
-		String result;
-
-		// default test
-		testSubject = createTestSubject();
-		result = testSubject.getType();
-	}
-
-	@Test
-	public void testSetType() throws Exception {
-		ToscaInterfaceDefinition testSubject;
-		String type = "";
-
-		// default test
-		testSubject = createTestSubject();
-		testSubject.setType(type);
-	}
-
-	@Test
-	public void testGetOperations() throws Exception {
-		ToscaInterfaceDefinition testSubject;
-		Map<String, Object> result;
-
-		// default test
-		testSubject = createTestSubject();
-		result = testSubject.getOperations();
-	}
-
-	@Test
-	public void testSetOperations() throws Exception {
-		ToscaInterfaceDefinition testSubject;
-		Map<String, Object> toscaOperations = null;
-
-		// default test
-		testSubject = createTestSubject();
-		testSubject.setOperations(toscaOperations);
-	}
-}
diff --git a/catalog-be/src/test/resources/config/catalog-be/error-configuration.yaml b/catalog-be/src/test/resources/config/catalog-be/error-configuration.yaml
index a28f31b1b0..50906d2624 100644
--- a/catalog-be/src/test/resources/config/catalog-be/error-configuration.yaml
+++ b/catalog-be/src/test/resources/config/catalog-be/error-configuration.yaml
@@ -2038,6 +2038,18 @@ errors:
         message: "Error: Failed to delete interface operation.",
         messageId: "SVC4702"
     }
+    #SVC4732
+    INTERFACE_UNKNOWN: {
+        code: 400,
+        message: "Error: The interface '%1' does not exists in the database.",
+        messageId: "SVC4732"
+    }
+    #SVC4733
+    INTERFACE_OPERATION_NOT_DEFINED: {
+        code: 400,
+        message: "Error: The operation '%1' does not exists in the interface '%2'.",
+        messageId: "SVC4733"
+    }
     #-----------SVC4692---------------------------
     RESOURCE_LIFECYCLE_STATE_NOT_VALID: {
         code: 400,
diff --git a/catalog-be/src/test/resources/interfaceDefinition/interfaceDefinition-legacy.yaml b/catalog-be/src/test/resources/interfaceDefinition/interfaceDefinition-legacy.yaml
new file mode 100644
index 0000000000..d12664be9d
--- /dev/null
+++ b/catalog-be/src/test/resources/interfaceDefinition/interfaceDefinition-legacy.yaml
@@ -0,0 +1,24 @@
+inputs:
+  stringInput:
+    type: string
+    description: stringInput description
+    required: true
+    default: defaultValue
+    status: aStatus
+  actionInput:
+    type: org.openecomp.resource.datatypes.Action
+type: tosca.interfaces.node.lifecycle.Standard
+create:
+  implementation: "camunda/serviceSelect"
+start:
+  implementation: "camunda/executeAction"
+  inputs:
+    action:
+      type: org.openecomp.resource.datatypes.Action
+stop:
+  implementation: "camunda/executeAction"
+  inputs:
+    action:
+      type: org.openecomp.resource.datatypes.Action
+delete:
+  implementation: "camunda/serviceDeselect"
\ No newline at end of file
diff --git a/catalog-be/src/test/resources/interfaceDefinition/interfaceDefinition-tosca1.3.yaml b/catalog-be/src/test/resources/interfaceDefinition/interfaceDefinition-tosca1.3.yaml
new file mode 100644
index 0000000000..13dfb9a1fb
--- /dev/null
+++ b/catalog-be/src/test/resources/interfaceDefinition/interfaceDefinition-tosca1.3.yaml
@@ -0,0 +1,25 @@
+inputs:
+  stringInput:
+    type: string
+    description: stringInput description
+    required: true
+    default: defaultValue
+    status: aStatus
+  actionInput:
+    type: org.openecomp.resource.datatypes.Action
+type: tosca.interfaces.node.lifecycle.Standard
+operations:
+  create:
+    implementation: "camunda/serviceSelect"
+  start:
+    implementation: "camunda/executeAction"
+    inputs:
+      action:
+        type: org.openecomp.resource.datatypes.Action
+  stop:
+    implementation: "camunda/executeAction"
+    inputs:
+      action:
+        type: org.openecomp.resource.datatypes.Action
+  delete:
+    implementation: "camunda/serviceDeselect"
\ No newline at end of file