Implement Attributes/Outputs BE (part 3)

This commit includes unit test for new/changed code

Change-Id: I619039f99c4a09484df098375067bdceee4636b0
Signed-off-by: Vasyl Razinkov <vasyl.razinkov@est.tech>
Issue-ID: SDC-3448

20 files changed, 1834 insertions, 163 deletions

diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ComponentInstanceBusinessLogicTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ComponentInstanceBusinessLogicTest.java
index 891d2c83ca..8a2cdef16e 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ComponentInstanceBusinessLogicTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ComponentInstanceBusinessLogicTest.java
@@ -27,14 +27,15 @@ import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertSame;
 import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.DynamicTest.dynamicTest;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anySet;
 import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
+import static org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum.RESOURCE_PARAM_NAME;
 
 import fj.data.Either;
 import java.util.ArrayList;
@@ -90,10 +91,10 @@ import org.openecomp.sdc.be.model.CapabilityDefinition;
 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
 import org.openecomp.sdc.be.model.Component;
 import org.openecomp.sdc.be.model.ComponentInstance;
+import org.openecomp.sdc.be.model.ComponentInstanceAttribute;
 import org.openecomp.sdc.be.model.ComponentInstanceInput;
 import org.openecomp.sdc.be.model.ComponentInstancePropInput;
 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
-import org.openecomp.sdc.be.model.ComponentInstanceAttribute;
 import org.openecomp.sdc.be.model.ComponentParametersView;
 import org.openecomp.sdc.be.model.DataTypeDefinition;
 import org.openecomp.sdc.be.model.InputDefinition;
@@ -1740,7 +1741,7 @@ class ComponentInstanceBusinessLogicTest {
         when(containerInstanceTypeData.isAllowedForResourceComponent(eq(ResourceTypeEnum.VF), eq(ResourceTypeEnum.VF)))
             .thenReturn(false);
         actualException = assertThrows(ByActionStatusComponentException.class, () -> {
-            componentInstanceBusinessLogic.createComponentInstance(ComponentTypeEnum.RESOURCE_PARAM_NAME, COMPONENT_ID, USER_ID, ci);
+            componentInstanceBusinessLogic.createComponentInstance(RESOURCE_PARAM_NAME, COMPONENT_ID, USER_ID, ci);
         });
         //then
         assertThat(actualException.getActionStatus()).isEqualTo(ActionStatus.CONTAINER_CANNOT_CONTAIN_INSTANCE);
@@ -1875,14 +1876,85 @@ class ComponentInstanceBusinessLogicTest {
         // Check graph db change was committed
         verify(janusGraphDao, times(1)).commit();
     }
-    
+
+    @Test
+    void testGetComponentInstanceAttributesById_success() {
+        final ComponentInstanceAttribute componentInstanceAttribute = new ComponentInstanceAttribute();
+        componentInstanceAttribute.setComponentInstanceId(TO_INSTANCE_ID);
+
+        final HashMap<String, List<ComponentInstanceAttribute>> map = new HashMap<>();
+        map.put(TO_INSTANCE_ID, Arrays.asList(componentInstanceAttribute));
+        resource.setComponentInstancesAttributes(map);
+
+        final Either<Component, StorageOperationStatus> leftServiceOp = Either.left(resource);
+        doReturn(leftServiceOp).when(toscaOperationFacade).getToscaElement(COMPONENT_ID);
+
+        final List<ComponentInstanceAttribute> result = componentInstanceBusinessLogic
+            .getComponentInstanceAttributesById(RESOURCE_PARAM_NAME, COMPONENT_ID, TO_INSTANCE_ID, USER_ID);
+        assertThat(result).isNotNull().isNotEmpty();
+        verify(toscaOperationFacade, times(1)).getToscaElement(COMPONENT_ID);
+    }
+
+    @Test
+    void testGetComponentInstanceAttributesById_fail_missing_ComponentInstancesAttributes() {
+        final Either<Component, StorageOperationStatus> leftServiceOp = Either.left(resource);
+        doReturn(leftServiceOp).when(toscaOperationFacade).getToscaElement(COMPONENT_ID);
+
+        final List<ComponentInstanceAttribute> result = componentInstanceBusinessLogic
+            .getComponentInstanceAttributesById(RESOURCE_PARAM_NAME, COMPONENT_ID, TO_INSTANCE_ID, USER_ID);
+        assertThat(result).isNotNull().isEmpty();
+        verify(toscaOperationFacade, times(1)).getToscaElement(COMPONENT_ID);
+    }
+
+    @Test
+    void testGetComponentInstanceAttributesById_fail_getToscaElement() {
+        final ComponentInstanceAttribute componentInstanceAttribute = new ComponentInstanceAttribute();
+        componentInstanceAttribute.setComponentInstanceId(TO_INSTANCE_ID);
+
+        final HashMap<String, List<ComponentInstanceAttribute>> map = new HashMap<>();
+        map.put(TO_INSTANCE_ID, Arrays.asList(componentInstanceAttribute));
+        resource.setComponentInstancesAttributes(map);
+
+        final Either<Object, StorageOperationStatus> right = Either.right(StorageOperationStatus.BAD_REQUEST);
+        doReturn(right).when(toscaOperationFacade).getToscaElement(COMPONENT_ID);
+        doReturn(ActionStatus.BAD_REQUEST_MISSING_RESOURCE).when(componentsUtils).convertFromStorageResponse(StorageOperationStatus.BAD_REQUEST);
+
+        assertThrows(ByActionStatusComponentException.class, () -> {
+            final List<ComponentInstanceAttribute> result = componentInstanceBusinessLogic
+                .getComponentInstanceAttributesById(RESOURCE_PARAM_NAME, COMPONENT_ID, TO_INSTANCE_ID, USER_ID);
+
+        });
+
+    }
+
+    @Test
+    void testGetComponentInstanceAttributesById_fail_getResourceInstanceById() {
+        final ComponentInstanceAttribute componentInstanceAttribute = new ComponentInstanceAttribute();
+        componentInstanceAttribute.setComponentInstanceId(TO_INSTANCE_ID);
+
+        final HashMap<String, List<ComponentInstanceAttribute>> map = new HashMap<>();
+        map.put(TO_INSTANCE_ID, Arrays.asList(componentInstanceAttribute));
+        resource.setComponentInstancesAttributes(map);
+
+        final Either<Component, StorageOperationStatus> leftServiceOp = Either.left(resource);
+        doReturn(leftServiceOp).when(toscaOperationFacade).getToscaElement(COMPONENT_ID);
+        doReturn(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE).when(componentsUtils).convertFromStorageResponse(StorageOperationStatus.PARENT_RESOURCE_NOT_FOUND);
+
+        assertThrows(ByActionStatusComponentException.class, () -> {
+            final List<ComponentInstanceAttribute> result = componentInstanceBusinessLogic
+                .getComponentInstanceAttributesById(RESOURCE_PARAM_NAME, COMPONENT_ID, "", USER_ID);
+
+        });
+
+    }
+
     private ComponentInstance createServiceSubstitutionComponentInstance() {
         final ComponentInstance instanceToBeCreated = new ComponentInstance();
         instanceToBeCreated.setName(COMPONENT_INSTANCE_NAME);
         instanceToBeCreated.setUniqueId(COMPONENT_INSTANCE_ID);
         instanceToBeCreated.setComponentUid(ORIGIN_COMPONENT_ID);
         instanceToBeCreated.setOriginType(OriginTypeEnum.ServiceSubstitution);
-        
+
         return instanceToBeCreated;
     }
     
@@ -1896,7 +1968,6 @@ class ComponentInstanceBusinessLogicTest {
         return originComponent;
     }
     
-    
     private Component createServiceSubstitutionServiceDerivedFromComponent() {
         final Resource component = new Resource();
         component.setLifecycleState(LifecycleStateEnum.CERTIFIED);
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/OutputsBusinessLogicTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/OutputsBusinessLogicTest.java
new file mode 100644
index 0000000000..4c74b5f640
--- /dev/null
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/OutputsBusinessLogicTest.java
@@ -0,0 +1,419 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2021, Nordix Foundation. 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.components.impl;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyMap;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import fj.data.Either;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.openecomp.sdc.be.components.attribute.AttributeDeclarationOrchestrator;
+import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
+import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
+import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
+import org.openecomp.sdc.be.components.utils.PropertyDataDefinitionBuilder;
+import org.openecomp.sdc.be.components.validation.UserValidations;
+import org.openecomp.sdc.be.config.ConfigurationManager;
+import org.openecomp.sdc.be.dao.api.ActionStatus;
+import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
+import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
+import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
+import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
+import org.openecomp.sdc.be.impl.ComponentsUtils;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.ComponentInstOutputsMap;
+import org.openecomp.sdc.be.model.ComponentInstance;
+import org.openecomp.sdc.be.model.ComponentInstanceOutput;
+import org.openecomp.sdc.be.model.ComponentInstanceAttribOutput;
+import org.openecomp.sdc.be.model.ComponentInstanceProperty;
+import org.openecomp.sdc.be.model.ComponentParametersView;
+import org.openecomp.sdc.be.model.DataTypeDefinition;
+import org.openecomp.sdc.be.model.OutputDefinition;
+import org.openecomp.sdc.be.model.LifecycleStateEnum;
+import org.openecomp.sdc.be.model.Resource;
+import org.openecomp.sdc.be.model.Service;
+import org.openecomp.sdc.be.model.User;
+import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
+import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
+import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.AttributeOperation;
+import org.openecomp.sdc.be.user.UserBusinessLogic;
+import org.openecomp.sdc.common.api.ConfigurationSource;
+import org.openecomp.sdc.common.impl.ExternalConfiguration;
+import org.openecomp.sdc.common.impl.FSConfigurationSource;
+import org.openecomp.sdc.exception.ResponseFormat;
+
+class OutputsBusinessLogicTest {
+
+    private static final String COMPONENT_INSTANCE_ID = "instanceId";
+    private static final String COMPONENT_ID = "componentId";
+    private static final String USER_ID = "userId";
+    private static final String OUTPUT_ID = "outputId";
+    private static final String OUTPUT_TYPE = "string";
+    private static final String LISTOUTPUT_NAME = "listOutput";
+    private static final String LISTOUTPUT_SCHEMA_TYPE = "org.onap.datatypes.listoutput";
+    private static final String LISTOUTPUT_PROP1_NAME = "prop1";
+    private static final String LISTOUTPUT_PROP1_TYPE = "string";
+    private static final String LISTOUTPUT_PROP2_NAME = "prop2";
+    private static final String LISTOUTPUT_PROP2_TYPE = "integer";
+    private static final String OLD_VALUE = "old value";
+    private static final String NEW_VALUE = "new value";
+    private final ConfigurationManager configurationManager =
+        new ConfigurationManager(new FSConfigurationSource(ExternalConfiguration.getChangeListener(), "src/test/resources/config/catalog-be"));
+
+    @Mock
+    private ComponentsUtils componentsUtilsMock;
+
+    @Mock
+    private UserBusinessLogic userAdminMock;
+
+    @Mock
+    private ToscaOperationFacade toscaOperationFacadeMock;
+
+    @Mock
+    private UserValidations userValidations;
+
+    @Mock
+    private IGraphLockOperation graphLockOperation;
+
+    @Mock
+    private AttributeDeclarationOrchestrator attributeDeclarationOrchestrator;
+
+    @Mock
+    private ApplicationDataTypeCache applicationDataTypeCache;
+
+    @Mock
+    private AttributeOperation attributeOperation;
+
+    @Mock
+    private JanusGraphDao janusGraphDao;
+
+    @InjectMocks
+    private OutputsBusinessLogic testInstance;
+
+    private Service service;
+
+    private Map<String, List<ComponentInstanceOutput>> instanceOutputMap;
+    private List<ComponentInstanceOutput> outputsList;
+
+    @BeforeEach
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        service = new Service();
+        service.setUniqueId(COMPONENT_ID);
+        service.setLastUpdaterUserId(USER_ID);
+        service.setIsDeleted(false);
+        service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+
+        testInstance.setUserValidations(userValidations);
+        testInstance.setToscaOperationFacade(toscaOperationFacadeMock);
+        testInstance.setGraphLockOperation(graphLockOperation);
+        testInstance.setComponentsUtils(componentsUtilsMock);
+        testInstance.setJanusGraphDao(janusGraphDao);
+        testInstance.setApplicationDataTypeCache(applicationDataTypeCache);
+        testInstance.setAttributeOperation(attributeOperation);
+
+        // add a ComponentInstance
+        final ComponentInstance componentInstance = new ComponentInstance();
+        componentInstance.setUniqueId(COMPONENT_INSTANCE_ID);
+        service.setComponentInstances(Collections.singletonList(componentInstance));
+
+        instanceOutputMap = new HashMap<>();
+        final ComponentInstanceOutput componentInstanceOutput = new ComponentInstanceOutput();
+        componentInstanceOutput.setOutputId(OUTPUT_ID);
+        componentInstanceOutput.setName(OUTPUT_ID);
+        outputsList = Collections.singletonList(componentInstanceOutput);
+        instanceOutputMap.put(COMPONENT_INSTANCE_ID, outputsList);
+        instanceOutputMap.put("someOutputId", Collections.singletonList(new ComponentInstanceOutput()));
+        service.setComponentInstancesOutputs(instanceOutputMap);
+        when(userValidations.validateUserExists(USER_ID)).thenReturn(new User());
+        when(userAdminMock.getUser(USER_ID, false)).thenReturn(new User());
+    }
+
+    @Test
+    void getComponentInstanceOutputs_ComponentInstanceNotExist() {
+        when(toscaOperationFacadeMock.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))).thenReturn(Either.left(service));
+        final Either<List<ComponentInstanceOutput>, ResponseFormat> componentInstanceOutputs = testInstance
+            .getComponentInstanceOutputs(USER_ID, COMPONENT_ID, "nonExisting");
+        assertThat(componentInstanceOutputs.isRight()).isTrue();
+        verify(componentsUtilsMock).getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND);
+    }
+
+    @Test
+    void getComponentInstanceOutputs_emptyOutputsMap() {
+        service.setComponentInstancesOutputs(Collections.emptyMap());
+        getComponents_emptyOutputs(service);
+    }
+
+    @Test
+    void getComponentInstanceOutputs_nullOutputsMap() {
+        service.setComponentInstancesOutputs(null);
+        getComponents_emptyOutputs(service);
+    }
+
+    @Test
+    void getComponentInstanceOutputs_instanceHasNoOutputs() {
+        service.setComponentInstancesOutputs(Collections.singletonMap("someOutputId", new ArrayList<>()));
+        getComponents_emptyOutputs(service);
+    }
+
+    @Test
+    void getComponentInstanceOutputs() {
+        when(toscaOperationFacadeMock.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))).thenReturn(Either.left(service));
+        final Either<List<ComponentInstanceOutput>, ResponseFormat> componentInstanceOutputs = testInstance
+            .getComponentInstanceOutputs(USER_ID, COMPONENT_ID, COMPONENT_INSTANCE_ID);
+        assertEquals("outputId", componentInstanceOutputs.left().value().get(0).getOutputId());
+    }
+
+    @Test
+    void testDeclareAttributes() {
+        service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+        service.setLastUpdaterUserId(USER_ID);
+        final ComponentInstOutputsMap componentInstOutputsMap = new ComponentInstOutputsMap();
+        final Map<String, List<ComponentInstanceAttribOutput>> propertiesForDeclaration = new HashMap<>();
+        propertiesForDeclaration.put(COMPONENT_ID, getPropertiesListForDeclaration());
+
+        final List<OutputDefinition> declaredPropertiesToOutputs = getDeclaredProperties();
+        initMockitoStubbings(declaredPropertiesToOutputs);
+
+        final Either<List<OutputDefinition>, ResponseFormat> declaredPropertiesEither =
+            testInstance.declareAttributes(USER_ID, COMPONENT_ID, ComponentTypeEnum.SERVICE, componentInstOutputsMap);
+
+        assertThat(declaredPropertiesEither.isLeft()).isTrue();
+
+        final List<OutputDefinition> declaredProperties = declaredPropertiesEither.left().value();
+        assertThat(CollectionUtils.isNotEmpty(declaredProperties)).isTrue();
+        assertEquals(1, declaredProperties.size());
+        assertEquals(declaredProperties, declaredPropertiesToOutputs);
+    }
+
+    @Test
+    void testDeclareAttributes_fail() {
+        service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+        service.setLastUpdaterUserId(USER_ID);
+        final ComponentInstOutputsMap componentInstOutputsMap = new ComponentInstOutputsMap();
+        final Map<String, List<ComponentInstanceAttribOutput>> propertiesForDeclaration = new HashMap<>();
+        propertiesForDeclaration.put(COMPONENT_ID, getPropertiesListForDeclaration());
+
+        final List<OutputDefinition> declaredPropertiesToOutputs = getDeclaredProperties();
+        initMockitoStubbings(declaredPropertiesToOutputs);
+        when(attributeDeclarationOrchestrator.declareAttributesToOutputs(any(), any())).thenThrow(ByResponseFormatComponentException.class);
+        final Either<List<OutputDefinition>, ResponseFormat> declaredPropertiesEither =
+            testInstance.declareAttributes(USER_ID, COMPONENT_ID, ComponentTypeEnum.SERVICE, componentInstOutputsMap);
+
+        assertThat(declaredPropertiesEither.isRight()).isTrue();
+
+    }
+
+    private void initMockitoStubbings(List<OutputDefinition> declaredPropertiesToOutputs) {
+        when(toscaOperationFacadeMock.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))).thenReturn(
+            Either.left(service));
+        when(attributeDeclarationOrchestrator.declareAttributesToOutputs(any(), any())).thenReturn(Either.left(
+            declaredPropertiesToOutputs));
+        when(toscaOperationFacadeMock.addOutputsToComponent(any(), any())).thenReturn(Either.left(declaredPropertiesToOutputs));
+        when(janusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
+        when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
+        when(graphLockOperation.unlockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
+    }
+
+    private void getComponents_emptyOutputs(Service service) {
+        when(toscaOperationFacadeMock.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))).thenReturn(Either.left(service));
+        final Either<List<ComponentInstanceOutput>, ResponseFormat> componentInstanceOutputs = testInstance
+            .getComponentInstanceOutputs(USER_ID, COMPONENT_ID, COMPONENT_INSTANCE_ID);
+        assertEquals(Collections.emptyList(), componentInstanceOutputs.left().value());
+    }
+
+    private List<ComponentInstanceAttribOutput> getPropertiesListForDeclaration() {
+        return outputsList.stream().map(this::getPropertyForDeclaration).collect(Collectors.toList());
+    }
+
+    private ComponentInstanceAttribOutput getPropertyForDeclaration(ComponentInstanceOutput componentInstanceOutput) {
+        final ComponentInstanceAttribOutput propOutput = new ComponentInstanceAttribOutput();
+        propOutput.setOutput(componentInstanceOutput);
+        propOutput.setAttributesName(componentInstanceOutput.getName());
+
+        return propOutput;
+    }
+
+    private List<OutputDefinition> getDeclaredProperties() {
+        return outputsList.stream().map(OutputDefinition::new).collect(Collectors.toList());
+    }
+
+    private OutputDefinition setUpListOutput() {
+        final OutputDefinition listOutput = new OutputDefinition();
+        listOutput.setName(LISTOUTPUT_NAME);
+        listOutput.setType("list");
+        return listOutput;
+    }
+
+    @Test
+    void test_deleteOutput_listOutput_fail_getComponent() throws Exception {
+        when(toscaOperationFacadeMock.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class)))
+            .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
+        when(componentsUtilsMock.convertFromStorageResponse(StorageOperationStatus.NOT_FOUND)).thenReturn(ActionStatus.RESOURCE_NOT_FOUND);
+
+        try {
+            testInstance.deleteOutput(COMPONENT_ID, USER_ID, LISTOUTPUT_NAME);
+        } catch (ComponentException e) {
+            assertEquals(ActionStatus.RESOURCE_NOT_FOUND, e.getActionStatus());
+            verify(toscaOperationFacadeMock, times(1)).getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class));
+            return;
+        }
+        fail();
+    }
+
+    @Test
+    void test_deleteOutput_listOutput_fail_validateOutput() throws Exception {
+        final OutputDefinition listOutput = setUpListOutput();
+        final String outputId = COMPONENT_ID + "." + listOutput.getName();
+        listOutput.setUniqueId(outputId);
+        service.setOutputs(Collections.singletonList(listOutput));
+        final String NONEXIST_OUTPUT_NAME = "myOutput";
+
+        when(toscaOperationFacadeMock.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class)))
+            .thenReturn(Either.left(service));
+
+        try {
+            testInstance.deleteOutput(COMPONENT_ID, USER_ID, NONEXIST_OUTPUT_NAME);
+        } catch (ComponentException e) {
+            assertEquals(ActionStatus.OUTPUT_IS_NOT_CHILD_OF_COMPONENT, e.getActionStatus());
+            verify(toscaOperationFacadeMock, times(1)).getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class));
+            return;
+        }
+        fail();
+    }
+
+    @Test
+    void test_deleteOutput_listOutput_fail_lockComponent() throws Exception {
+        final OutputDefinition listOutput = setUpListOutput();
+        final String outputId = COMPONENT_ID + "." + listOutput.getName();
+        listOutput.setUniqueId(outputId);
+        service.setOutputs(Collections.singletonList(listOutput));
+
+        when(toscaOperationFacadeMock.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class)))
+            .thenReturn(Either.left(service));
+        when(graphLockOperation.lockComponent(COMPONENT_ID, NodeTypeEnum.Service)).thenReturn(StorageOperationStatus.NOT_FOUND);
+        when(componentsUtilsMock.convertFromStorageResponse(StorageOperationStatus.NOT_FOUND, ComponentTypeEnum.SERVICE))
+            .thenReturn(ActionStatus.SERVICE_NOT_FOUND);
+
+        try {
+            testInstance.deleteOutput(COMPONENT_ID, USER_ID, outputId);
+        } catch (ComponentException e) {
+            assertEquals(ActionStatus.SERVICE_NOT_FOUND, e.getActionStatus());
+            verify(toscaOperationFacadeMock, times(1)).getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class));
+            verify(graphLockOperation, times(1)).lockComponent(COMPONENT_ID, NodeTypeEnum.Service);
+            return;
+        }
+        fail();
+    }
+
+    @Test
+    void test_deleteOutput_listOutput_fail_deleteOutput() throws Exception {
+        final OutputDefinition listOutput = setUpListOutput();
+        final String outputId = COMPONENT_ID + "." + listOutput.getName();
+        listOutput.setUniqueId(outputId);
+        service.setOutputs(Collections.singletonList(listOutput));
+
+        when(toscaOperationFacadeMock.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class)))
+            .thenReturn(Either.left(service));
+        when(graphLockOperation.lockComponent(COMPONENT_ID, NodeTypeEnum.Service)).thenReturn(StorageOperationStatus.OK);
+        when(toscaOperationFacadeMock.deleteOutputOfResource(service, listOutput.getName())).thenReturn(StorageOperationStatus.BAD_REQUEST);
+        when(componentsUtilsMock.convertFromStorageResponse(StorageOperationStatus.BAD_REQUEST)).thenReturn(ActionStatus.INVALID_CONTENT);
+
+        try {
+            testInstance.deleteOutput(COMPONENT_ID, USER_ID, outputId);
+        } catch (ComponentException e) {
+            assertEquals(ActionStatus.INVALID_CONTENT, e.getActionStatus());
+            verify(toscaOperationFacadeMock, times(1)).getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class));
+            verify(graphLockOperation, times(1)).lockComponent(COMPONENT_ID, NodeTypeEnum.Service);
+            verify(toscaOperationFacadeMock, times(1)).deleteOutputOfResource(service, listOutput.getName());
+            return;
+        }
+        fail();
+    }
+
+    @Test
+    void test_deleteOutput_output_fail_unDeclare() throws Exception {
+        final OutputDefinition listOutput = setUpListOutput();
+        final String outputId = COMPONENT_ID + "." + listOutput.getName();
+        listOutput.setUniqueId(outputId);
+        service.setOutputs(Collections.singletonList(listOutput));
+
+        when(toscaOperationFacadeMock.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class)))
+            .thenReturn(Either.left(service));
+        when(graphLockOperation.lockComponent(COMPONENT_ID, NodeTypeEnum.Service)).thenReturn(StorageOperationStatus.OK);
+        when(toscaOperationFacadeMock.deleteOutputOfResource(service, listOutput.getName())).thenReturn(StorageOperationStatus.OK);
+        when(attributeDeclarationOrchestrator.unDeclareAttributesAsOutputs(service, listOutput)).thenReturn(StorageOperationStatus.BAD_REQUEST);
+        when(componentsUtilsMock.convertFromStorageResponse(StorageOperationStatus.BAD_REQUEST)).thenReturn(ActionStatus.INVALID_CONTENT);
+
+        try {
+            testInstance.deleteOutput(COMPONENT_ID, USER_ID, outputId);
+        } catch (ComponentException e) {
+            assertEquals(ActionStatus.INVALID_CONTENT, e.getActionStatus());
+            verify(attributeDeclarationOrchestrator, times(1)).unDeclareAttributesAsOutputs(service, listOutput);
+            return;
+        }
+        fail();
+    }
+
+    @Test
+    void test_deleteOutput_output_success() throws Exception {
+        final OutputDefinition listOutput = setUpListOutput();
+        final String outputId = COMPONENT_ID + "." + listOutput.getName();
+        listOutput.setUniqueId(outputId);
+        service.setOutputs(Collections.singletonList(listOutput));
+
+        when(toscaOperationFacadeMock.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class)))
+            .thenReturn(Either.left(service));
+        when(graphLockOperation.lockComponent(COMPONENT_ID, NodeTypeEnum.Service)).thenReturn(StorageOperationStatus.OK);
+        when(toscaOperationFacadeMock.deleteOutputOfResource(service, listOutput.getName())).thenReturn(StorageOperationStatus.OK);
+        when(attributeDeclarationOrchestrator.unDeclareAttributesAsOutputs(service, listOutput)).thenReturn(StorageOperationStatus.OK);
+
+        testInstance.deleteOutput(COMPONENT_ID, USER_ID, outputId);
+        verify(attributeDeclarationOrchestrator, times(1)).unDeclareAttributesAsOutputs(service, listOutput);
+    }
+
+}
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogicTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogicTest.java
index d219347fc4..09f4ac72de 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogicTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogicTest.java
@@ -241,7 +241,7 @@ public class ResourceBusinessLogicTest {
 		user.setRole(Role.ADMIN.name());
 
 		when(mockUserAdmin.getUser("jh0003", false)).thenReturn(user);
-		when(userValidations.validateUserExists(eq(user.getUserId()))).thenReturn(user);
+		when(userValidations.validateUserExists(user.getUserId())).thenReturn(user);
 		when(userValidations.validateUserNotEmpty(eq(user), anyString())).thenReturn(user);
 		// Servlet Context attributes
 		when(servletContext.getAttribute(Constants.CONFIGURATION_MANAGER_ATTR)).thenReturn(configurationManager);
@@ -1620,7 +1620,7 @@ public class ResourceBusinessLogicTest {
 		assertThat(createOrUpdateResource).isNotNull();
 
 		Mockito.verify(toscaOperationFacade, times(1))
-				.createToscaComponent(eq(resourceToUpdtae));
+				.createToscaComponent(resourceToUpdtae);
 		Mockito.verify(toscaOperationFacade, Mockito.times(0))
 				.overrideComponent(any(Resource.class), any(Resource.class));
 		Mockito.verify(lifecycleBl, Mockito.times(0))
@@ -1663,7 +1663,7 @@ public class ResourceBusinessLogicTest {
 		assertThat(createOrUpdateResource).isNotNull();
 
 		Mockito.verify(toscaOperationFacade, times(1))
-				.createToscaComponent(eq(resourceToUpdate));
+				.createToscaComponent(resourceToUpdate);
 		Mockito.verify(toscaOperationFacade, times(0))
 				.overrideComponent(any(Resource.class), any(Resource.class));
 		Mockito.verify(lifecycleBl, times(0))
@@ -2187,6 +2187,7 @@ public class ResourceBusinessLogicTest {
 		Resource resource = getResourceWithType("HEAT_VOL", "org.openecomp.groups.VfModule");
 		resource.setGroups(null);
 		bl.updateVolumeGroup(resource);
+		assertThat(resource.getGroups()).isNull();
 	}
 
 	@Test
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/utils/ComponentBuilder.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/utils/ComponentBuilder.java
index 0c6ba53491..0dad76ebfe 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/utils/ComponentBuilder.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/utils/ComponentBuilder.java
@@ -30,6 +30,7 @@ import org.openecomp.sdc.be.model.ComponentInstanceProperty;
 import org.openecomp.sdc.be.model.GroupDefinition;
 import org.openecomp.sdc.be.model.InputDefinition;
 import org.openecomp.sdc.be.model.LifecycleStateEnum;
+import org.openecomp.sdc.be.model.OutputDefinition;
 import org.openecomp.sdc.be.model.PolicyDefinition;
 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
 
@@ -132,6 +133,22 @@ public abstract class ComponentBuilder<T extends Component, B extends ComponentB
         return self();
     }
 
+    public ComponentBuilder<T, B> addOutput(final OutputDefinition output) {
+        if (component.getOutputs() == null) {
+            component.setOutputs(new ArrayList<>());
+        }
+        component.getOutputs().add(output);
+        return self();
+    }
+
+    public ComponentBuilder<T, B> addOutput(final String outputName) {
+        final OutputDefinition outputDefinition = new OutputDefinition();
+        outputDefinition.setName(outputName);
+        outputDefinition.setUniqueId(outputName);
+        this.addOutput(outputDefinition);
+        return self();
+    }
+
     public ComponentBuilder<T, B> addInstanceProperty(String instanceId, ComponentInstanceProperty prop) {
         if (component.getComponentInstancesProperties() == null) {
             component.setComponentInstancesProperties(new HashMap<>());
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/datamodel/UiComponentDataConverterTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/datamodel/UiComponentDataConverterTest.java
index ffe3d06e2a..f163b51f66 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/datamodel/UiComponentDataConverterTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/datamodel/UiComponentDataConverterTest.java
@@ -48,6 +48,7 @@ import org.openecomp.sdc.be.model.ComponentInstanceProperty;
 import org.openecomp.sdc.be.model.GroupDefinition;
 import org.openecomp.sdc.be.model.InputDefinition;
 import org.openecomp.sdc.be.model.InterfaceDefinition;
+import org.openecomp.sdc.be.model.OutputDefinition;
 import org.openecomp.sdc.be.model.PolicyDefinition;
 import org.openecomp.sdc.be.model.PropertyDefinition;
 import org.openecomp.sdc.be.model.Resource;
@@ -61,6 +62,7 @@ public class UiComponentDataConverterTest {
     private PolicyDefinition policy1, policy2;
     private GroupDefinition group1, group2;
     private InputDefinition input1;
+    private OutputDefinition output;
     private PropertyDefinition propertyDef;
     private InterfaceDefinition interfaceDef;
 
@@ -149,6 +151,7 @@ public class UiComponentDataConverterTest {
     public void getUiDataTransferFromResourceByParams_All() {
         Resource resourceWithGroups = buildResourceWithGroups();
         Resource resourceWithInputs = buildResourceWithInputs();
+        Resource resourceWithOutputs = buildResourceWithOutputs();
 
         UiComponentDataTransfer componentDTO1 = uiComponentDataConverter.getUiDataTransferFromResourceByParams(resourceWithGroups, Collections.singletonList("PROPERTIES"));
         UiComponentDataTransfer componentDTO2 = uiComponentDataConverter.getUiDataTransferFromResourceByParams(resourceWithGroups, Collections.singletonList("properties"));
@@ -160,6 +163,7 @@ public class UiComponentDataConverterTest {
 
         UiComponentDataTransfer componentDTO8 = uiComponentDataConverter.getUiDataTransferFromResourceByParams(resourceWithGroups, Collections.singletonList("inputs"));
         UiComponentDataTransfer componentDTO81 = uiComponentDataConverter.getUiDataTransferFromResourceByParams(resourceWithInputs, Collections.singletonList("inputs"));
+        UiComponentDataTransfer componentDTO82 = uiComponentDataConverter.getUiDataTransferFromResourceByParams(resourceWithOutputs, Collections.singletonList("outputs"));
 
         UiComponentDataTransfer componentDTO9 = uiComponentDataConverter.getUiDataTransferFromResourceByParams(resourceWithGroups, Collections.singletonList("users"));
         UiComponentDataTransfer componentDTO10 = uiComponentDataConverter.getUiDataTransferFromResourceByParams(resourceWithGroups, Collections.singletonList("componentInstances"));
@@ -202,7 +206,7 @@ public class UiComponentDataConverterTest {
     @Test
     public void getUiDataTransferFromServiceByParams_METADATA() {
         UiServiceDataTransfer componentDTO = (UiServiceDataTransfer) uiComponentDataConverter.getUiDataTransferFromServiceByParams(new Service(), Collections.singletonList("metadata"));
-        assertThat(componentDTO.getMetadata().getNamingPolicy()).isEqualTo("");
+        assertThat(componentDTO.getMetadata().getNamingPolicy()).isEmpty();
     }
 
     @Test
@@ -348,22 +352,30 @@ public class UiComponentDataConverterTest {
                 .build();
     }
 
-    private Resource buildResourceWithParameter(String field) {
-        ResourceBuilder res =  new ResourceBuilder();
+    private Resource buildResourceWithOutputs() {
+        return new ResourceBuilder()
+                .addOutput(output)
+                .build();
+    }
+
+    private Resource buildResourceWithParameter(final String field) {
+        final ResourceBuilder res =  new ResourceBuilder();
         switch(field){
             case "inputs":
                 res.addInput(input1);
                 break;
+            case "outputs":
+                res.addOutput(output);
+                break;
             case "properties":
                 //res.addProperty(propertyDef);
                 break;
 
 
         }
-
-
         return new ResourceBuilder()
                 .addInput(input1)
+                .addOutput(output)
                 .build();
     }
 
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/servlets/ComponentAttributeServletTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/servlets/ComponentAttributeServletTest.java
new file mode 100644
index 0000000000..123ef9a5ec
--- /dev/null
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/servlets/ComponentAttributeServletTest.java
@@ -0,0 +1,148 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2021, Nordix Foundation. 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.servlets;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
+
+import fj.data.Either;
+import java.util.Arrays;
+import java.util.List;
+import javax.servlet.ServletContext;
+import javax.servlet.http.HttpSession;
+import javax.ws.rs.core.Response;
+import org.assertj.core.api.Assertions;
+import org.glassfish.grizzly.http.util.HttpStatus;
+import org.junit.Assert;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Spy;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.openecomp.sdc.be.components.impl.AttributeBusinessLogic;
+import org.openecomp.sdc.be.dao.api.ActionStatus;
+import org.openecomp.sdc.be.impl.ComponentsUtils;
+import org.openecomp.sdc.be.impl.WebAppContextWrapper;
+import org.openecomp.sdc.be.model.AttributeDefinition;
+import org.openecomp.sdc.common.api.Constants;
+import org.openecomp.sdc.exception.ResponseFormat;
+import org.springframework.web.context.WebApplicationContext;
+
+@ExtendWith(MockitoExtension.class)
+class ComponentAttributeServletTest extends JerseySpringBaseTest {
+
+    @Mock
+    private ServletContext context;
+    @Mock
+    private WebAppContextWrapper wrapper;
+    @Mock
+    private WebApplicationContext webAppContext;
+    @Mock
+    private HttpSession session;
+    @Mock
+    private AttributeBusinessLogic attributeBusinessLogic;
+    @Mock
+    private ComponentsUtils componentsUtils;
+    @InjectMocks
+    @Spy
+    private ComponentAttributeServlet componentAttributeServlet;
+
+    private static final String SERVICE_ID = "service1";
+    private static final String RESOURCE_ID = "resource1";
+    private static final String USER_ID = "jh0003";
+    private static final String VALID_PROPERTY_NAME = "valid_name_123";
+    private static final String INVALID_PROPERTY_NAME = "invalid_name_$.&";
+    private static final String STRING_TYPE = "string";
+
+    @BeforeEach
+    public void initClass() throws Exception {
+        super.setUp();
+        when(request.getSession()).thenReturn(session);
+    }
+
+    @AfterEach
+    public void tearDown() throws Exception {
+        super.tearDown();
+    }
+
+    @Test
+    void getAttributeListInService_success() {
+        AttributeDefinition attributeDefinition = new AttributeDefinition();
+        attributeDefinition.setName(VALID_PROPERTY_NAME);
+        attributeDefinition.setType(STRING_TYPE);
+
+        List<AttributeDefinition> attributeDefinitionEntryData = Arrays.asList(attributeDefinition);
+        when(attributeBusinessLogic.getAttributesList(any(), any())).thenReturn(Either.left(attributeDefinitionEntryData));
+
+        Response attributeInService = componentAttributeServlet.getAttributeListInService(SERVICE_ID, request, USER_ID);
+
+        Assert.assertEquals(HttpStatus.OK_200.getStatusCode(), attributeInService.getStatus());
+    }
+
+    @Test
+    void getAttributeListInService_fail() {
+        when(attributeBusinessLogic.getAttributesList(any(), any()))
+            .thenReturn(Either.right(new ResponseFormat(Response.Status.NOT_FOUND.getStatusCode())));
+
+        Response attributeInService = componentAttributeServlet.getAttributeListInService(SERVICE_ID, request, USER_ID);
+
+        Assertions.assertThat(attributeInService).isNotNull();
+        Assertions.assertThat(attributeInService.getStatus()).isEqualTo(Response.Status.NOT_FOUND.getStatusCode());
+    }
+
+    @Test
+    void getAttributeListInResource_success() {
+        AttributeDefinition attributeDefinition = new AttributeDefinition();
+        attributeDefinition.setName(VALID_PROPERTY_NAME);
+        attributeDefinition.setType(STRING_TYPE);
+
+        List<AttributeDefinition> attributeDefinitionEntryData = Arrays.asList(attributeDefinition);
+        when(attributeBusinessLogic.getAttributesList(any(), any())).thenReturn(Either.left(attributeDefinitionEntryData));
+        when(attributeBusinessLogic.getAttributesList(any(), any())).thenReturn(Either.left(attributeDefinitionEntryData));
+
+        Response attributeInService =
+            componentAttributeServlet.getAttributeListInResource(RESOURCE_ID, request, USER_ID);
+
+        Assert.assertEquals(HttpStatus.OK_200.getStatusCode(), attributeInService.getStatus());
+    }
+
+    @Test
+    void getAttributeListInResource_fail() {
+        when(session.getServletContext()).thenReturn(context);
+        when(context.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR)).thenReturn(wrapper);
+        when(wrapper.getWebAppContext(any())).thenReturn(webAppContext);
+        when(webAppContext.getBean(ComponentsUtils.class)).thenReturn(componentsUtils);
+        when(attributeBusinessLogic.getAttributesList(any(), any())).thenThrow(new RuntimeException());
+
+        ResponseFormat responseFormat = new ResponseFormat(HttpStatus.BAD_REQUEST_400.getStatusCode());
+
+        when(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR)).thenReturn(responseFormat);
+
+        Response attributeInService = componentAttributeServlet.getAttributeListInResource(SERVICE_ID, request, USER_ID);
+
+        Assertions.assertThat(attributeInService).isNotNull();
+        Assertions.assertThat(attributeInService.getStatus()).isEqualTo(HttpStatus.BAD_REQUEST_400.getStatusCode());
+    }
+
+}
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/servlets/OutputsServletTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/servlets/OutputsServletTest.java
new file mode 100644
index 0000000000..6b0cf70ecb
--- /dev/null
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/servlets/OutputsServletTest.java
@@ -0,0 +1,263 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2021, Nordix Foundation. 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.servlets;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum.RESOURCE;
+
+import fj.data.Either;
+import java.util.ArrayList;
+import java.util.List;
+import javax.servlet.ServletContext;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpSession;
+import javax.ws.rs.core.Application;
+import javax.ws.rs.core.Response;
+import org.assertj.core.api.Assertions;
+import org.glassfish.grizzly.http.util.HttpStatus;
+import org.glassfish.hk2.utilities.binding.AbstractBinder;
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.test.JerseyTest;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.api.TestInstance.Lifecycle;
+import org.openecomp.sdc.be.components.impl.ComponentInstanceBusinessLogic;
+import org.openecomp.sdc.be.components.impl.OutputsBusinessLogic;
+import org.openecomp.sdc.be.components.impl.ResourceImportManager;
+import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
+import org.openecomp.sdc.be.config.SpringConfig;
+import org.openecomp.sdc.be.dao.api.ActionStatus;
+import org.openecomp.sdc.be.impl.ComponentsUtils;
+import org.openecomp.sdc.be.impl.ServletUtils;
+import org.openecomp.sdc.be.impl.WebAppContextWrapper;
+import org.openecomp.sdc.be.model.ComponentInstOutputsMap;
+import org.openecomp.sdc.be.model.OutputDefinition;
+import org.openecomp.sdc.be.model.User;
+import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
+import org.openecomp.sdc.be.servlets.exception.ComponentExceptionMapper;
+import org.openecomp.sdc.be.user.UserBusinessLogic;
+import org.openecomp.sdc.common.api.Constants;
+import org.openecomp.sdc.exception.ResponseFormat;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.web.context.WebApplicationContext;
+
+@TestInstance(Lifecycle.PER_CLASS)
+class OutputsServletTest extends JerseyTest {
+
+    private static final String USER_ID = "jh0003";
+    private static final String COMPONENT_ID = "componentId";
+    private static final String RESOURCES = "resources";
+    private static final String COMPONENT_INST_OUTPUTS_MAP_OBJ = "componentInstOutputsMapObj";
+    private static final String OUTPUT_ID = "outputId";
+    private static final String INSTANCE_ID = "instanceId";
+    private static final String COMPONENT_UID = "originComponentUid";
+
+    private final UserBusinessLogic userBusinessLogic = mock(UserBusinessLogic.class);
+    private final OutputsBusinessLogic outputsBusinessLogic = mock(OutputsBusinessLogic.class);
+    private final ComponentInstanceBusinessLogic componentInstanceBL = mock(ComponentInstanceBusinessLogic.class);
+    private final HttpSession httpSession = mock(HttpSession.class);
+    private final ServletContext servletContext = mock(ServletContext.class);
+    private final WebApplicationContext webApplicationContext = mock(WebApplicationContext.class);
+    private final ComponentsUtils componentsUtils = mock(ComponentsUtils.class);
+    private final ServletUtils servletUtils = mock(ServletUtils.class);
+    private final ResourceImportManager resourceImportManager = mock(ResourceImportManager.class);
+    private final HttpServletRequest request = mock(HttpServletRequest.class);
+    private final WebAppContextWrapper wrapper = mock(WebAppContextWrapper.class);
+
+    @Override
+    @BeforeEach
+    public void setUp() throws Exception {
+        super.setUp();
+        when(request.getSession()).thenReturn(httpSession);
+        when(httpSession.getServletContext()).thenReturn(servletContext);
+        when(servletContext.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR)).thenReturn(wrapper);
+        when(wrapper.getWebAppContext(any())).thenReturn(webApplicationContext);
+        when(webApplicationContext.getBean(OutputsBusinessLogic.class)).thenReturn(outputsBusinessLogic);
+        when(servletUtils.getComponentsUtils()).thenReturn(componentsUtils);
+    }
+
+    @Override
+    @AfterEach
+    public void tearDown() throws Exception {
+        super.tearDown();
+    }
+
+    @Test
+    void test_getComponentInstanceOutputs_success() {
+        final Either<List<OutputDefinition>, ResponseFormat> listResponseFormatEither = Either.left(new ArrayList<>());
+        doReturn(listResponseFormatEither).when(outputsBusinessLogic).getComponentInstanceOutputs(USER_ID, COMPONENT_ID, INSTANCE_ID);
+
+        final ResponseFormat responseFormat = new ResponseFormat(HttpStatus.OK_200.getStatusCode());
+        doReturn(responseFormat).when(componentsUtils).getResponseFormat(ActionStatus.OK);
+
+        final OutputsServlet outputsServlet = createTestObject();
+        Assertions.assertThat(outputsServlet).isNotNull();
+
+        final Response response = outputsServlet.getComponentInstanceOutputs(RESOURCES, COMPONENT_ID, INSTANCE_ID, COMPONENT_UID, request, USER_ID);
+        Assertions.assertThat(response.getStatus()).isEqualTo(HttpStatus.OK_200.getStatusCode());
+        verify(componentsUtils, times(2)).getResponseFormat(ActionStatus.OK);
+    }
+
+    @Test
+    void test_getComponentInstanceOutputs_isRight() {
+        final ResponseFormat responseFormat = new ResponseFormat(HttpStatus.BAD_REQUEST_400.getStatusCode());
+        final Either<Object, ResponseFormat> right = Either.right(responseFormat);
+        doReturn(right).when(outputsBusinessLogic).getComponentInstanceOutputs(USER_ID, COMPONENT_ID, INSTANCE_ID);
+
+        doReturn(responseFormat).when(componentsUtils).getResponseFormat(ActionStatus.GENERAL_ERROR);
+
+        final OutputsServlet outputsServlet = createTestObject();
+        Assertions.assertThat(outputsServlet).isNotNull();
+
+        final Response response = outputsServlet.getComponentInstanceOutputs(RESOURCES, COMPONENT_ID, INSTANCE_ID, COMPONENT_UID, request, USER_ID);
+        Assertions.assertThat(response.getStatus()).isEqualTo(HttpStatus.BAD_REQUEST_400.getStatusCode());
+        verify(componentsUtils, times(0)).getResponseFormat(ActionStatus.GENERAL_ERROR);
+    }
+
+    @Test
+    void test_getComponentInstanceOutputs_fail() {
+        final ResponseFormat responseFormat = new ResponseFormat(HttpStatus.BAD_REQUEST_400.getStatusCode());
+        final Either<Object, ResponseFormat> right = Either.right(responseFormat);
+        doReturn(right).when(outputsBusinessLogic).getComponentInstanceOutputs(USER_ID, COMPONENT_ID, INSTANCE_ID);
+
+        doThrow(new RuntimeException()).when(componentsUtils).getResponseFormat(ActionStatus.GENERAL_ERROR);
+
+        final OutputsServlet outputsServlet = createTestObject();
+        Assertions.assertThat(outputsServlet).isNotNull();
+
+        final Response response = outputsServlet.getComponentInstanceOutputs(RESOURCES, COMPONENT_ID, INSTANCE_ID, COMPONENT_UID, request, USER_ID);
+        Assertions.assertThat(response.getStatus()).isEqualTo(HttpStatus.BAD_REQUEST_400.getStatusCode());
+        verify(componentsUtils, times(0)).getResponseFormat(ActionStatus.GENERAL_ERROR);
+    }
+
+    @Test
+    void test_createMultipleOutputs_success() {
+        final ComponentInstOutputsMap componentInstOutputsMap = new ComponentInstOutputsMap();
+        final Either<ComponentInstOutputsMap, ResponseFormat> left = Either.left(componentInstOutputsMap);
+
+        doReturn(left).when(componentsUtils)
+            .convertJsonToObjectUsingObjectMapper(any(String.class), any(User.class), eq(ComponentInstOutputsMap.class),
+                eq(AuditingActionEnum.CREATE_RESOURCE), eq(RESOURCE));
+        final Either<List<OutputDefinition>, ResponseFormat> listResponseFormatEither = Either.left(new ArrayList<>());
+        doReturn(listResponseFormatEither).when(outputsBusinessLogic).declareAttributes(USER_ID, COMPONENT_ID, RESOURCE, componentInstOutputsMap);
+
+        final ResponseFormat responseFormat = new ResponseFormat(HttpStatus.OK_200.getStatusCode());
+        doReturn(responseFormat).when(componentsUtils).getResponseFormat(ActionStatus.OK);
+
+        final OutputsServlet outputsServlet = createTestObject();
+        Assertions.assertThat(outputsServlet).isNotNull();
+
+        final Response response = outputsServlet.createMultipleOutputs(RESOURCES, COMPONENT_ID, request, USER_ID, COMPONENT_INST_OUTPUTS_MAP_OBJ);
+        Assertions.assertThat(response.getStatus()).isEqualTo(HttpStatus.OK_200.getStatusCode());
+        verify(componentsUtils, times(3)).getResponseFormat(ActionStatus.OK);
+    }
+
+    @Test
+    void test_createMultipleOutputs_isRight() {
+        final ResponseFormat responseFormat = new ResponseFormat(HttpStatus.BAD_REQUEST_400.getStatusCode());
+        final Either<Object, ResponseFormat> right = Either.right(responseFormat);
+        doReturn(right).when(outputsBusinessLogic).declareAttributes(USER_ID, COMPONENT_ID, RESOURCE, new ComponentInstOutputsMap());
+
+        doReturn(responseFormat).when(componentsUtils).getResponseFormat(ActionStatus.GENERAL_ERROR);
+
+        final OutputsServlet outputsServlet = createTestObject();
+        Assertions.assertThat(outputsServlet).isNotNull();
+
+        final Response response = outputsServlet.createMultipleOutputs(RESOURCES, COMPONENT_ID, request, USER_ID, COMPONENT_INST_OUTPUTS_MAP_OBJ);
+        Assertions.assertThat(response.getStatus()).isEqualTo(HttpStatus.BAD_REQUEST_400.getStatusCode());
+        verify(componentsUtils, times(3)).getResponseFormat(ActionStatus.GENERAL_ERROR);
+    }
+
+    @Test
+    void test_createMultipleOutputs_fail() {
+        final ResponseFormat responseFormat = new ResponseFormat(HttpStatus.BAD_REQUEST_400.getStatusCode());
+        doThrow(new RuntimeException()).when(outputsBusinessLogic).declareAttributes(USER_ID, COMPONENT_ID, RESOURCE, new ComponentInstOutputsMap());
+
+        doReturn(responseFormat).when(componentsUtils).getResponseFormat(ActionStatus.GENERAL_ERROR);
+
+        final OutputsServlet outputsServlet = createTestObject();
+        Assertions.assertThat(outputsServlet).isNotNull();
+
+        final Response response = outputsServlet.createMultipleOutputs(RESOURCES, COMPONENT_ID, request, USER_ID, COMPONENT_INST_OUTPUTS_MAP_OBJ);
+        Assertions.assertThat(response.getStatus()).isEqualTo(HttpStatus.BAD_REQUEST_400.getStatusCode());
+        verify(componentsUtils, times(2)).getResponseFormat(ActionStatus.GENERAL_ERROR);
+    }
+
+    @Test
+    void test_deleteOutput_success() {
+        doReturn(new OutputDefinition()).when(outputsBusinessLogic).deleteOutput(COMPONENT_ID, USER_ID, OUTPUT_ID);
+
+        final ResponseFormat responseFormat = new ResponseFormat(HttpStatus.OK_200.getStatusCode());
+        doReturn(responseFormat).when(componentsUtils).getResponseFormat(ActionStatus.OK);
+
+        final OutputsServlet outputsServlet = createTestObject();
+        Assertions.assertThat(outputsServlet).isNotNull();
+
+        final Response response = outputsServlet.deleteOutput(RESOURCES, COMPONENT_ID, OUTPUT_ID, request, USER_ID, COMPONENT_INST_OUTPUTS_MAP_OBJ);
+        Assertions.assertThat(response.getStatus()).isEqualTo(HttpStatus.OK_200.getStatusCode());
+        verify(componentsUtils, times(1)).getResponseFormat(ActionStatus.OK);
+    }
+
+    @Test
+    void test_deleteOutput_fail() {
+        final ResponseFormat responseFormat = new ResponseFormat(HttpStatus.BAD_REQUEST_400.getStatusCode());
+        doThrow(new ComponentException(responseFormat)).when(outputsBusinessLogic).deleteOutput(COMPONENT_ID, USER_ID, OUTPUT_ID);
+
+        doReturn(responseFormat).when(componentsUtils).getResponseFormat(ActionStatus.GENERAL_ERROR);
+
+        final OutputsServlet outputsServlet = createTestObject();
+        Assertions.assertThat(outputsServlet).isNotNull();
+
+        final Response response = outputsServlet.deleteOutput(RESOURCES, COMPONENT_ID, OUTPUT_ID, request, USER_ID, COMPONENT_INST_OUTPUTS_MAP_OBJ);
+        Assertions.assertThat(response.getStatus()).isEqualTo(HttpStatus.BAD_REQUEST_400.getStatusCode());
+        verify(componentsUtils, times(1)).getResponseFormat(ActionStatus.GENERAL_ERROR);
+    }
+
+    private OutputsServlet createTestObject() {
+        return new OutputsServlet(userBusinessLogic, outputsBusinessLogic, componentInstanceBL, componentsUtils, servletUtils, resourceImportManager);
+    }
+
+    @Override
+    protected Application configure() {
+        final OutputsServlet outputsServlet = createTestObject();
+        final ResourceConfig resourceConfig = new ResourceConfig()
+            .register(outputsServlet)
+            .register(new ComponentExceptionMapper(componentsUtils))
+            .register(new AbstractBinder() {
+                @Override
+                protected void configure() {
+                    bind(request).to(HttpServletRequest.class);
+                }
+            });
+
+        resourceConfig.property("contextConfig", new AnnotationConfigApplicationContext(SpringConfig.class));
+        return resourceConfig;
+    }
+
+}
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/servlets/TypesUploadServletTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/servlets/TypesUploadServletTest.java
index 993e68b97e..214d1a7aba 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/servlets/TypesUploadServletTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/servlets/TypesUploadServletTest.java
@@ -48,7 +48,11 @@ import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.api.TestInstance.Lifecycle;
+import org.mockito.Mock;
 import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
 import org.openecomp.sdc.be.components.impl.CapabilityTypeImportManager;
 import org.openecomp.sdc.be.config.ConfigurationManager;
 import org.openecomp.sdc.be.config.SpringConfig;
@@ -69,21 +73,32 @@ import org.springframework.context.ApplicationContext;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 import org.springframework.web.context.WebApplicationContext;
 
+@TestInstance(Lifecycle.PER_CLASS)
 class TypesUploadServletTest extends JerseyTest {
 
-    public static final HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
-    private static final HttpSession session = Mockito.mock(HttpSession.class);
-    public static final ServletContext servletContext = Mockito.mock(ServletContext.class);
-    public static final WebAppContextWrapper webAppContextWrapper = Mockito.mock(WebAppContextWrapper.class);
-    private static final WebApplicationContext webApplicationContext = Mockito.mock(WebApplicationContext.class);
-    private static final CapabilityTypeImportManager importManager = Mockito.mock(CapabilityTypeImportManager.class);
-    private static final ServletUtils servletUtils = Mockito.mock(ServletUtils.class);
-    private static final UserBusinessLogic userAdmin = Mockito.mock(UserBusinessLogic.class);
-    private static final ComponentsUtils componentUtils = Mockito.mock(ComponentsUtils.class);
-    private static final ResponseFormat responseFormat = Mockito.mock(ResponseFormat.class);
+    @Mock
+    private HttpServletRequest request;
+    @Mock
+    private HttpSession session;
+    @Mock
+    private ServletContext servletContext;
+    @Mock
+    private WebAppContextWrapper webAppContextWrapper;
+    @Mock
+    private WebApplicationContext webApplicationContext;
+    @Mock
+    private CapabilityTypeImportManager importManager;
+    @Mock
+    private ServletUtils servletUtils;
+    @Mock
+    private UserBusinessLogic userAdmin;
+    @Mock
+    private ComponentsUtils componentUtils;
+    @Mock
+    private ResponseFormat responseFormat;
 
     @BeforeAll
-    public static void setup() {
+    public void setup() {
         ExternalConfiguration.setAppName("catalog-be");
         when(servletContext.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR))
             .thenReturn(webAppContextWrapper);
@@ -92,15 +107,13 @@ class TypesUploadServletTest extends JerseyTest {
         when(webApplicationContext.getBean(ServletUtils.class)).thenReturn(servletUtils);
         when(servletUtils.getComponentsUtils()).thenReturn(componentUtils);
         when(servletUtils.getUserAdmin()).thenReturn(userAdmin);
-        String userId = "jh0003";
-        User user = new User();
-        user.setUserId(userId);
+        final String userId = "jh0003";
+        final User user = new User(userId);
         user.setRole(Role.ADMIN.name());
         when(userAdmin.getUser(userId)).thenReturn(user);
         when(request.getHeader(Constants.USER_ID_HEADER)).thenReturn(userId);
         when(responseFormat.getStatus()).thenReturn(HttpStatus.CREATED_201);
         when(componentUtils.getResponseFormat(ActionStatus.CREATED)).thenReturn(responseFormat);
-
     }
 
     @BeforeEach
@@ -115,19 +128,16 @@ class TypesUploadServletTest extends JerseyTest {
 
     @Test
     void creatingCapabilityTypeSuccessTest() {
-        Either<List<ImmutablePair<CapabilityTypeDefinition, Boolean>>, ResponseFormat> either = Either
-            .left(emptyList());
+        final Either<List<ImmutablePair<CapabilityTypeDefinition, Boolean>>, ResponseFormat> either = Either.left(emptyList());
         when(importManager.createCapabilityTypes(Mockito.anyString())).thenReturn(either);
-        FileDataBodyPart filePart = new FileDataBodyPart("capabilityTypeZip",
-            new File("src/test/resources/types/capabilityTypes.zip"));
+        final FileDataBodyPart filePart = new FileDataBodyPart("capabilityTypeZip", new File("src/test/resources/types/capabilityTypes.zip"));
         MultiPart multipartEntity = new FormDataMultiPart();
         multipartEntity.bodyPart(filePart);
 
-        Response response = target().path("/v1/catalog/uploadType/capability").request(MediaType.APPLICATION_JSON)
+        final Response response = target().path("/v1/catalog/uploadType/capability").request(MediaType.APPLICATION_JSON)
             .post(Entity.entity(multipartEntity, MediaType.MULTIPART_FORM_DATA), Response.class);
 
         assertEquals(HttpStatus.CREATED_201, response.getStatus());
-
     }
 
     @Override
@@ -137,17 +147,17 @@ class TypesUploadServletTest extends JerseyTest {
 
     @Override
     protected ResourceConfig configure() {
+        MockitoAnnotations.openMocks(this);
 
-        TypesUploadServlet typesUploadServlet = new TypesUploadServlet(null, null, componentUtils,
+        forceSet(TestProperties.CONTAINER_PORT, "0");
+        final TypesUploadServlet typesUploadServlet = new TypesUploadServlet(null, null, componentUtils,
             servletUtils, null, importManager, null,
             null, null,
             null, null, null);
-        ResourceConfig resourceConfig = new ResourceConfig()
-            .register(typesUploadServlet);
+        final ResourceConfig resourceConfig = new ResourceConfig().register(typesUploadServlet);
 
         resourceConfig.register(MultiPartFeature.class);
         resourceConfig.register(new AbstractBinder() {
-
             @Override
             protected void configure() {
                 // The below code was cut-pasted to here from setup() because
@@ -160,17 +170,15 @@ class TypesUploadServletTest extends JerseyTest {
                 ConfigurationSource configurationSource = new FSConfigurationSource(
                     ExternalConfiguration.getChangeListener(), appConfigDir);
                 ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
-                for (String mandatoryHeader : configurationManager.getConfiguration().getIdentificationHeaderFields()) {
-
+                for (final String mandatoryHeader : configurationManager.getConfiguration().getIdentificationHeaderFields()) {
                     when(request.getHeader(mandatoryHeader)).thenReturn(mandatoryHeader);
-
                 }
 
                 when(servletContext.getAttribute(Constants.CONFIGURATION_MANAGER_ATTR))
                     .thenReturn(configurationManager);
             }
         });
-        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
+        final ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
         resourceConfig.property("contextConfig", context);
 
         return resourceConfig;
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/AttributeConverterTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/AttributeConverterTest.java
index 8292568d8e..2bd529541b 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/AttributeConverterTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/AttributeConverterTest.java
@@ -19,7 +19,6 @@
 
 package org.openecomp.sdc.be.tosca;
 
-
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -130,7 +129,6 @@ class AttributeConverterTest {
         assertAttribute(attributeDefinition, defaultValueMap, actualToscaAttribute);
     }
 
-
     @Test
     void testInvalidDefaultValueJsonConversion() {
         //given
@@ -143,8 +141,7 @@ class AttributeConverterTest {
         assertEquals("Failed to parse json value", toscaConversionException.getMessage());
     }
 
-    private void assertAttribute(final AttributeDefinition expectedAttributeDefinition,
-                                 final ToscaAttribute actualToscaAttribute) {
+    private void assertAttribute(final AttributeDefinition expectedAttributeDefinition, final ToscaAttribute actualToscaAttribute) {
         assertAttribute(expectedAttributeDefinition, expectedAttributeDefinition.get_default(), actualToscaAttribute);
     }
 
@@ -170,4 +167,4 @@ class AttributeConverterTest {
         return objectMapper.writeValueAsString(value);
     }
 
-}
\ No newline at end of file
+}
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java
index 4b55a730fb..bca8827736 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java
@@ -82,6 +82,8 @@ import org.openecomp.sdc.be.model.CapabilityDefinition;
 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
 import org.openecomp.sdc.be.model.Component;
 import org.openecomp.sdc.be.model.ComponentInstance;
+import org.openecomp.sdc.be.model.ComponentInstanceAttribOutput;
+import org.openecomp.sdc.be.model.ComponentInstanceAttribute;
 import org.openecomp.sdc.be.model.ComponentInstanceInput;
 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
 import org.openecomp.sdc.be.model.ComponentParametersView;
@@ -90,6 +92,7 @@ import org.openecomp.sdc.be.model.GroupDefinition;
 import org.openecomp.sdc.be.model.GroupInstance;
 import org.openecomp.sdc.be.model.InputDefinition;
 import org.openecomp.sdc.be.model.InterfaceDefinition;
+import org.openecomp.sdc.be.model.OutputDefinition;
 import org.openecomp.sdc.be.model.PropertyDefinition;
 import org.openecomp.sdc.be.model.RelationshipInfo;
 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
@@ -102,6 +105,7 @@ import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
+import org.openecomp.sdc.be.tosca.exception.ToscaConversionException;
 import org.openecomp.sdc.be.tosca.model.SubstitutionMapping;
 import org.openecomp.sdc.be.tosca.model.ToscaCapability;
 import org.openecomp.sdc.be.tosca.model.ToscaMetadata;
@@ -378,11 +382,11 @@ public class ToscaExportHandlerTest extends BeConfDependentTest {
     @Test
     public void testConvertToscaTemplate() throws Exception {
 
-        Component component = getNewResource();
-        ToscaTemplate toscaNode = new ToscaTemplate("");
+        final Component component = getNewResource();
+        final ToscaTemplate toscaNode = new ToscaTemplate("");
         Either<ToscaTemplate, ToscaError> result;
-        List<ComponentInstance> resourceInstances = new ArrayList<>();
-        ComponentInstance instance = new ComponentInstance();
+        final List<ComponentInstance> resourceInstances = new ArrayList<>();
+        final ComponentInstance instance = new ComponentInstance();
 
         instance.setOriginType(OriginTypeEnum.SERVICE);
         instance.setSourceModelUid("targetModelUid");
@@ -391,8 +395,11 @@ public class ToscaExportHandlerTest extends BeConfDependentTest {
         component.setComponentInstances(resourceInstances);
 
         when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
-        when(capabilityRequirementConverter.getOriginComponent(any(Map.class),
-            any(ComponentInstance.class))).thenReturn(Either.right(false));
+        when(capabilityRequirementConverter.getOriginComponent(any(Map.class), any(ComponentInstance.class))).thenReturn(Either.right(false));
+
+        final Map<String, ToscaProperty> map = new HashMap<>();
+        map.put("mock", new ToscaProperty());
+        doReturn(map).when(outputConverter).convert(any(), any());
 
         // default test
         result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
@@ -400,7 +407,7 @@ public class ToscaExportHandlerTest extends BeConfDependentTest {
     }
 
     @Test
-    public void testConvertToscaTemplateWhenComponentContainsGroup() {
+    public void testConvertToscaTemplateWhenComponentContainsGroup() throws ToscaConversionException {
         Component component = getNewResource();
         ToscaTemplate toscaNode = new ToscaTemplate("");
         Either<ToscaTemplate, ToscaError> result;
@@ -432,6 +439,10 @@ public class ToscaExportHandlerTest extends BeConfDependentTest {
 
         when(groupExportParser.getGroups(component)).thenReturn(null);
 
+        final Map<String, ToscaProperty> map = new HashMap<>();
+        map.put("mock", new ToscaProperty());
+        doReturn(map).when(outputConverter).convert(any(), any());
+
         // test component contains group
         result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
         Assert.assertNotNull(result);
@@ -467,6 +478,10 @@ public class ToscaExportHandlerTest extends BeConfDependentTest {
         when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
 
         when(inputConverter.convertInputs(anyList(), anyMap())).thenReturn(new HashMap<>());
+        final Map<String, ToscaProperty> map = new HashMap<>();
+        map.put("mock", new ToscaProperty());
+        doReturn(map).when(outputConverter).convert(any(), any());
+
         // test component contains group
         result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
         Assert.assertNotNull(result);
@@ -536,6 +551,7 @@ public class ToscaExportHandlerTest extends BeConfDependentTest {
 
         // default test
         Deencapsulation.invoke(testSubject, "createDependency", componentCache, imports, dependecies, ci);
+        Assert.assertFalse(componentCache.isEmpty());
     }
 
     @Test
@@ -1524,11 +1540,9 @@ public class ToscaExportHandlerTest extends BeConfDependentTest {
     @Test
     public void testIsCvfc() throws Exception {
 
-        Component component = new Resource();
+        Component component = new Service();
         boolean result;
 
-        component = new Service();
-
         result = Deencapsulation.invoke(testSubject, "isCvfc", component);
         Assert.assertFalse(result);
     }
@@ -1576,8 +1590,8 @@ public class ToscaExportHandlerTest extends BeConfDependentTest {
         result = Deencapsulation.invoke(testSubject, "convertToNodeTemplateArtifacts", container);
         Assert.assertNotNull(result);
         Assert.assertTrue(MapUtils.isNotEmpty(result));
-        Assert.assertEquals("test_file",result.get("test_art").getFile());
-        Assert.assertEquals("test_type",result.get("test_art").getType());
+        Assert.assertEquals("test_file", result.get("test_art").getFile());
+        Assert.assertEquals("test_type", result.get("test_art").getType());
     }
 
     @Test
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/utils/OutputConverterTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/utils/OutputConverterTest.java
new file mode 100644
index 0000000000..392c524471
--- /dev/null
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/utils/OutputConverterTest.java
@@ -0,0 +1,67 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2021, Nordix Foundation. 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.utils;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doReturn;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.openecomp.sdc.be.model.OutputDefinition;
+import org.openecomp.sdc.be.tosca.AttributeConverter;
+import org.openecomp.sdc.be.tosca.exception.ToscaConversionException;
+import org.openecomp.sdc.be.tosca.model.ToscaProperty;
+import org.springframework.beans.factory.ObjectProvider;
+
+@ExtendWith(MockitoExtension.class)
+class OutputConverterTest {
+
+    @InjectMocks
+    private OutputConverter testSubject;
+
+    @Mock
+    private ObjectProvider<AttributeConverter> attributeConverterProvider;
+
+    @Test
+    void test_convert_success() throws ToscaConversionException {
+        final List<OutputDefinition> outputDefinitionList = new ArrayList<>();
+        final OutputDefinition outputDefinition = new OutputDefinition();
+        outputDefinitionList.add(outputDefinition);
+
+        doReturn(new AttributeConverter(new HashMap<>())).when(attributeConverterProvider).getObject(any());
+        final Map<String, ToscaProperty> result = testSubject.convert(outputDefinitionList, new HashMap<>());
+        assertThat(result).isNotNull();
+    }
+
+    @Test
+    void test_convert_isEmpty() throws ToscaConversionException {
+        final Map<String, ToscaProperty> result = testSubject.convert(new ArrayList<>(), new HashMap<>());
+        assertThat(result).isNotNull().isEmpty();
+    }
+
+}
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/AttributeDefinitionTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/AttributeDefinitionTest.java
new file mode 100644
index 0000000000..a6d87df05e
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/AttributeDefinitionTest.java
@@ -0,0 +1,50 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2021, Nordix Foundation. 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.model;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.Test;
+import org.openecomp.sdc.be.datatypes.elements.AttributeDataDefinition;
+
+class AttributeDefinitionTest {
+
+    private static final String VALUE = "mock";
+    private final AttributeDefinition testSubject = new AttributeDefinition();
+
+    @Test
+    void testCtor() throws Exception {
+        assertNotNull(new AttributeDefinition());
+        assertNotNull(new AttributeDefinition(new AttributeDefinition()));
+        assertNotNull(new AttributeDefinition(new AttributeDataDefinition()));
+    }
+
+    @Test
+    void test_DefaultValue() {
+        testSubject.setDefaultValue(VALUE);
+        final String result = testSubject.getDefaultValue();
+        assertEquals(VALUE, result);
+    }
+
+    @Test
+    void test_isDefinition() {
+        assertFalse(testSubject.isDefinition());
+    }
+}
\ No newline at end of file
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/ComponentInstOutputsMapTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/ComponentInstOutputsMapTest.java
new file mode 100644
index 0000000000..79a69df62f
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/ComponentInstOutputsMapTest.java
@@ -0,0 +1,70 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2021, Nordix Foundation. 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.model;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.apache.commons.lang3.tuple.Pair;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class ComponentInstOutputsMapTest {
+
+    private final ComponentInstOutputsMap testInstance = new ComponentInstOutputsMap();
+
+    @Test
+    void test_resolveAttributesToDeclare_isEmpty() {
+        Assertions.assertThrows(IllegalStateException.class, () -> {
+            final Pair<String, List<ComponentInstanceAttribOutput>> result = testInstance.resolveAttributesToDeclare();
+        });
+    }
+
+    @Test
+    void test_resolveAttributesToDeclare_success() {
+        Map<String, List<ComponentInstanceAttribOutput>> map = new HashMap<>();
+        map.put("mock", Arrays.asList(new ComponentInstanceAttribOutput()));
+        testInstance.setComponentInstanceOutputsMap(map);
+        testInstance.setComponentInstanceAttributes(null);
+        Pair<String, List<ComponentInstanceAttribOutput>> result = testInstance.resolveAttributesToDeclare();
+        Assertions.assertNotNull(result);
+
+        testInstance.setComponentInstanceOutputsMap(null);
+        testInstance.setComponentInstanceAttributes(map);
+        result = testInstance.resolveAttributesToDeclare();
+        Assertions.assertNotNull(result);
+    }
+
+    @Test
+    void test_getComponentInstanceOutputsMap() {
+        final Map<String, List<ComponentInstanceAttribOutput>> result = testInstance.getComponentInstanceOutputsMap();
+        Assertions.assertNotNull(result);
+    }
+
+    @Test
+    void test_getComponentInstanceAttributes() {
+        final Map<String, List<ComponentInstanceAttribOutput>> result = testInstance.getComponentInstanceAttributes();
+        Assertions.assertNotNull(result);
+    }
+
+}
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/ComponentInstanceAttribOutputTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/ComponentInstanceAttribOutputTest.java
new file mode 100644
index 0000000000..27be652b7a
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/ComponentInstanceAttribOutputTest.java
@@ -0,0 +1,55 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2021, Nordix Foundation. 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.model;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class ComponentInstanceAttribOutputTest {
+
+    private final ComponentInstanceAttribOutput testSubject = new ComponentInstanceAttribOutput();
+
+    @Test
+    void testCtor() throws Exception {
+        Assertions.assertThat(testSubject).isNotNull().isInstanceOf(ComponentInstanceAttribOutput.class);
+        Assertions.assertThat(new ComponentInstanceAttribOutput(testSubject)).isNotNull().isInstanceOf(ComponentInstanceAttribOutput.class);
+    }
+
+    @Test
+    void test_getParsedAttribNames() {
+        String[] result;
+
+        testSubject.setAttributesName("");
+        result = testSubject.getParsedAttribNames();
+        assertNull(result);
+
+        testSubject.setAttributesName("ZZZ");
+        result = testSubject.getParsedAttribNames();
+        assertNotNull(result);
+        assertEquals(1, result.length);
+
+        testSubject.setAttributesName("AAA#BBB#CCC");
+        result = testSubject.getParsedAttribNames();
+        assertNotNull(result);
+        assertEquals(3, result.length);
+    }
+}
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/ComponentInstanceOutputTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/ComponentInstanceOutputTest.java
new file mode 100644
index 0000000000..29b2dc4659
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/ComponentInstanceOutputTest.java
@@ -0,0 +1,42 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2021, Nordix Foundation. 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.model;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.List;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.openecomp.sdc.be.datatypes.elements.AttributeDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.PropertyRule;
+
+class ComponentInstanceOutputTest {
+
+    private static final String MOCK = "mock";
+
+    @Test
+    void testCtor() throws Exception {
+        Assertions.assertNotNull(new ComponentInstanceOutput(new AttributeDataDefinition()));
+        Assertions.assertNotNull(new ComponentInstanceOutput(new OutputDefinition(), MOCK, MOCK));
+        Assertions.assertNotNull(new ComponentInstanceOutput(new AttributeDataDefinition(), MOCK, MOCK, MOCK));
+    }
+
+}
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTemplateOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTemplateOperationTest.java
index aea07799b2..cf4d6b22bf 100644
--- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTemplateOperationTest.java
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTemplateOperationTest.java
@@ -36,22 +36,28 @@ import org.apache.tinkerpop.gremlin.structure.Direction;
 import org.apache.tinkerpop.gremlin.structure.Edge;
 import org.apache.tinkerpop.gremlin.structure.Vertex;
 import org.janusgraph.core.JanusGraphVertex;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.api.TestInstance.Lifecycle;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentMatchers;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.Test;
 import org.mockito.Mockito;
 import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoExtension;
 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
+import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
 import org.openecomp.sdc.be.datatypes.elements.*;
 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
+import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
+import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
 import org.openecomp.sdc.be.model.*;
 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate;
 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement;
@@ -64,27 +70,34 @@ import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
+import static org.codehaus.groovy.runtime.DefaultGroovyMethods.any;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.anyList;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
-@RunWith(MockitoJUnitRunner.class)
-public class NodeTemplateOperationTest extends ModelTestBase {
-
-    private final static String COMPONENT_ID = "componentId";
-    private final static String TO_INSTANCE_ID = "toInstanceId";
-    private final static String FROM_INSTANCE_ID = "fromInstanceId";
-    private final static String RELATION_ID = "relationId";
-    private final static String CAPABILITY_OWNER_ID = "capabilityOwnerId";
-    private final static String CAPABILITY_UID = "capabilityUid";
-    private final static String CAPABILITY_NAME = "capabilityName";
-    private final static String REQUIREMENT_OWNER_ID = "requirementOwnerId";
-    private final static String REQUIREMENT_UID = "requirementUid";
-    private final static String REQUIREMENT_NAME = "requirementName";
-    private final static String RELATIONSHIP_TYPE = "relationshipType";
+@ExtendWith(MockitoExtension.class)
+@TestInstance(Lifecycle.PER_CLASS)
+class NodeTemplateOperationTest extends ModelTestBase {
+
+    private static final String COMPONENT_ID = "componentId";
+    private static final String TO_INSTANCE_ID = "toInstanceId";
+    private static final String FROM_INSTANCE_ID = "fromInstanceId";
+    private static final String RELATION_ID = "relationId";
+    private static final String CAPABILITY_OWNER_ID = "capabilityOwnerId";
+    private static final String CAPABILITY_UID = "capabilityUid";
+    private static final String CAPABILITY_NAME = "capabilityName";
+    private static final String REQUIREMENT_OWNER_ID = "requirementOwnerId";
+    private static final String REQUIREMENT_UID = "requirementUid";
+    private static final String REQUIREMENT_NAME = "requirementName";
+    private static final String RELATIONSHIP_TYPE = "relationshipType";
 
     private static Map<String, MapListCapabilityDataDefinition> fulfilledCapability;
     private static Map<String, MapListRequirementDataDefinition> fulfilledRequirement;
@@ -92,19 +105,15 @@ public class NodeTemplateOperationTest extends ModelTestBase {
     private static RequirementDataDefinition requirement;
     private static RequirementCapabilityRelDef relation;
 
-    @InjectMocks
-    private static NodeTemplateOperation operation;
-
-    @Mock
-    private static JanusGraphDao janusGraphDao;
+    private final JanusGraphDao janusGraphDao = Mockito.mock(JanusGraphDao.class);
+    private final TopologyTemplateOperation topologyTemplateOperation = Mockito.mock(TopologyTemplateOperation.class);
 
-    @Mock
-    private static TopologyTemplateOperation topologyTemplateOperation;
+    @InjectMocks
+    private NodeTemplateOperation operation;
 
-    @BeforeClass
-    public static void setup() {
+    @BeforeAll
+    public void setup() {
         init();
-        janusGraphDao = Mockito.mock(JanusGraphDao.class);
         operation = new NodeTemplateOperation();
         operation.setJanusGraphDao(janusGraphDao);
         buildDataDefinition();
@@ -117,7 +126,7 @@ public class NodeTemplateOperationTest extends ModelTestBase {
     }
 
     @Test
-    public void testGetFulfilledCapabilityByRelationSuccess(){
+    void testGetFulfilledCapabilityByRelationSuccess() {
         GraphVertex vertex = Mockito.mock(GraphVertex.class);
         Either<GraphVertex, JanusGraphOperationStatus> vertexRes = Either.left(vertex);
         when(janusGraphDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
@@ -132,7 +141,7 @@ public class NodeTemplateOperationTest extends ModelTestBase {
     }
 
     @Test
-    public void testGetFulfilledRequirementByRelationSuccess(){
+    void testGetFulfilledRequirementByRelationSuccess() {
         GraphVertex vertex = Mockito.mock(GraphVertex.class);
         Either<GraphVertex, JanusGraphOperationStatus> vertexRes = Either.left(vertex);
         when(janusGraphDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
@@ -147,7 +156,7 @@ public class NodeTemplateOperationTest extends ModelTestBase {
     }
 
     @Test
-    public void testGetFulfilledCapabilityByRelationNotFoundFailure(){
+    void testGetFulfilledCapabilityByRelationNotFoundFailure() {
         GraphVertex vertex = Mockito.mock(GraphVertex.class);
         Either<GraphVertex, JanusGraphOperationStatus> vertexRes = Either.left(vertex);
         when(janusGraphDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
@@ -157,11 +166,11 @@ public class NodeTemplateOperationTest extends ModelTestBase {
         when(janusGraphDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_CAPABILITIES), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes);
         Either<CapabilityDataDefinition, StorageOperationStatus> result = operation.getFulfilledCapabilityByRelation(COMPONENT_ID, TO_INSTANCE_ID, relation, this::isBelongingCapability);
         assertTrue(result.isRight());
-        assertSame(result.right().value(), StorageOperationStatus.NOT_FOUND);
+        assertSame(StorageOperationStatus.NOT_FOUND, result.right().value());
     }
 
     @Test
-    public void testGetFulfilledRequirementByRelationNotFoundFailure(){
+    void testGetFulfilledRequirementByRelationNotFoundFailure() {
         GraphVertex vertex = Mockito.mock(GraphVertex.class);
         Either<GraphVertex, JanusGraphOperationStatus> vertexRes = Either.left(vertex);
         when(janusGraphDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
@@ -171,11 +180,11 @@ public class NodeTemplateOperationTest extends ModelTestBase {
         when(janusGraphDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_REQUIREMENTS), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes);
         Either<RequirementDataDefinition, StorageOperationStatus> result = operation.getFulfilledRequirementByRelation(COMPONENT_ID, FROM_INSTANCE_ID, relation, this::isBelongingRequirement);
         assertTrue(result.isRight());
-        assertSame(result.right().value(), StorageOperationStatus.NOT_FOUND);
+        assertSame(StorageOperationStatus.NOT_FOUND, result.right().value());
     }
 
     @Test
-    public void testUpdateCIMetadataOfTopologyTemplate() {
+    void testUpdateCIMetadataOfTopologyTemplate() {
         Either<ImmutablePair<TopologyTemplate, String>, StorageOperationStatus> result;
         String id = "id";
         TopologyTemplate container = new TopologyTemplate();
@@ -194,16 +203,16 @@ public class NodeTemplateOperationTest extends ModelTestBase {
         assertTrue(result.isLeft());
     }
 
-	@Test
-	public void testGetDefaultHeatTimeout() {
-		Integer result;
+    @Test
+    void testGetDefaultHeatTimeout() {
+        Integer result;
 
-		// default test
-		result = NodeTemplateOperation.getDefaultHeatTimeout();
+        // default test
+        result = NodeTemplateOperation.getDefaultHeatTimeout();
     }
 
-	@Test
-    public void testPrepareInstDeploymentArtifactPerInstance() {
+    @Test
+    void testPrepareInstDeploymentArtifactPerInstance() {
         Map<String, Object> deploymentResourceArtifacts = new HashMap<>();
         Map<String, ArtifactDataDefinition> deploymentArtifacts = new HashMap<>();
         ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
@@ -220,22 +229,22 @@ public class NodeTemplateOperationTest extends ModelTestBase {
         MapArtifactDataDefinition result;
 
         result = operation.prepareInstDeploymentArtifactPerInstance(deploymentArtifacts, componentInstanceId, user,
-                envType);
-        Assert.assertEquals(2, result.getMapToscaDataDefinition().size());
+            envType);
+        assertEquals(2, result.getMapToscaDataDefinition().size());
     }
 
-	@Test
-	public void testCreateCapPropertyKey() throws Exception {
-		String key = "";
-		String instanceId = "";
-		String result;
+    @Test
+    void testCreateCapPropertyKey() throws Exception {
+        String key = "";
+        String instanceId = "";
+        String result;
 
-		// default test
-		result = NodeTemplateOperation.createCapPropertyKey(key, instanceId);
-	}
+        // default test
+        result = NodeTemplateOperation.createCapPropertyKey(key, instanceId);
+    }
 
-	@Test
-	public void testPrepareCalculatedCapabiltyForNodeType() {
+    @Test
+    void testPrepareCalculatedCapabiltyForNodeType() {
         Map<String, ListCapabilityDataDefinition> capabilities = new HashMap<>();
         ListCapabilityDataDefinition listCapDataDefinition = new ListCapabilityDataDefinition();
         List<CapabilityDataDefinition> listToscaDataDefinition = new ArrayList<>();
@@ -248,11 +257,11 @@ public class NodeTemplateOperationTest extends ModelTestBase {
         MapListCapabilityDataDefinition result;
 
         result = operation.prepareCalculatedCapabiltyForNodeType(capabilities, componentInstance);
-        Assert.assertEquals(1, result.getMapToscaDataDefinition().size());
+        assertEquals(1, result.getMapToscaDataDefinition().size());
 	}
 
     @Test
-    public void testPrepareCalculatedReqForNodeType() {
+    void testPrepareCalculatedReqForNodeType() {
         Map<String, ListRequirementDataDefinition> requirements = new HashMap<>();
         ListRequirementDataDefinition listReqDataDef = new ListRequirementDataDefinition();
         List<RequirementDataDefinition> listToscaDataDefinition = new ArrayList<>();
@@ -265,43 +274,43 @@ public class NodeTemplateOperationTest extends ModelTestBase {
         MapListRequirementDataDefinition result;
 
         result = operation.prepareCalculatedRequirementForNodeType(requirements, componentInstance);
-        Assert.assertEquals(1, result.getMapToscaDataDefinition().size());
+        assertEquals(1, result.getMapToscaDataDefinition().size());
     }
 
-	@Test
-	public void testAddGroupInstancesToComponentInstance() throws Exception {
-		Component containerComponent = null;
-		ComponentInstanceDataDefinition componentInstance = null;
-		List<GroupDefinition> groups = null;
-		Map<String, List<ArtifactDefinition>> groupInstancesArtifacts = null;
-		StorageOperationStatus result;
-
-		result = operation.addGroupInstancesToComponentInstance(containerComponent, componentInstance, groups,
-				groupInstancesArtifacts);
-		Assert.assertEquals(StorageOperationStatus.OK, result);
-	}
+    @Test
+    void testAddGroupInstancesToComponentInstance() throws Exception {
+        Component containerComponent = null;
+        ComponentInstanceDataDefinition componentInstance = null;
+        List<GroupDefinition> groups = null;
+        Map<String, List<ArtifactDefinition>> groupInstancesArtifacts = null;
+        StorageOperationStatus result;
+
+        result = operation.addGroupInstancesToComponentInstance(containerComponent, componentInstance, groups,
+            groupInstancesArtifacts);
+        assertEquals(StorageOperationStatus.OK, result);
+    }
 
-	@Test
-	public void testGenerateCustomizationUUIDOnInstanceGroup() throws Exception {
-		String componentId = "";
-		String instanceId = "";
-		List<String> groupInstances = null;
-		StorageOperationStatus result;
+    @Test
+    void testGenerateCustomizationUUIDOnInstanceGroup() throws Exception {
+        String componentId = "";
+        String instanceId = "";
+        List<String> groupInstances = null;
+        StorageOperationStatus result;
 
-		result = operation.generateCustomizationUUIDOnInstanceGroup(componentId, instanceId, groupInstances);
-		Assert.assertEquals(StorageOperationStatus.OK, result);
-	}
-	
-	@Test
-	public void testUpdateComponentInstanceRequirement() {
+        result = operation.generateCustomizationUUIDOnInstanceGroup(componentId, instanceId, groupInstances);
+        assertEquals(StorageOperationStatus.OK, result);
+    }
+
+    @Test
+    void testUpdateComponentInstanceRequirement() {
         String componentId = "";
         String componentInstanceId = "requirementOwnerId";
-        
+
         GraphVertex graphVertex = new GraphVertex();
         graphVertex.setUniqueId("uniqueId");
         when(janusGraphDao.getVertexById(componentId, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex));
         when(janusGraphDao.updateVertex(graphVertex)).thenReturn(Either.left(graphVertex));
-        
+
         MapListRequirementDataDefinition mapListRequirementDataDefinition = new MapListRequirementDataDefinition();
         mapListRequirementDataDefinition.add(requirement.getCapability(), requirement);
         Map<String, MapListRequirementDataDefinition> mapOfRequirements = new HashMap<>();
@@ -326,16 +335,108 @@ public class NodeTemplateOperationTest extends ModelTestBase {
             }
         };
         String outId = (String) janusGraphDao
-                .getProperty((JanusGraphVertex) outVertex, GraphPropertyEnum.UNIQUE_ID.getProperty());
+            .getProperty((JanusGraphVertex) outVertex, GraphPropertyEnum.UNIQUE_ID.getProperty());
         when(janusGraphDao.getProperty(outVertex, GraphPropertyEnum.UNIQUE_ID.getProperty())).thenReturn("uniqueId");
         when(janusGraphDao.updateVertex(childVertex)).thenReturn(Either.left(childVertex));
         JanusGraphVertex janusGraphVertex = Mockito.mock(JanusGraphVertex.class);
         childVertex.setVertex(janusGraphVertex);
         when(janusGraphVertex.edges(Direction.IN, EdgeLabelEnum.CALCULATED_REQUIREMENTS.name())).thenReturn(edgeIterator);
-                
-	    StorageOperationStatus result = operation.updateComponentInstanceRequirement(componentId, componentInstanceId, requirement);
-	    assertEquals(StorageOperationStatus.OK, result);
-	}
+
+        StorageOperationStatus result = operation.updateComponentInstanceRequirement(componentId, componentInstanceId, requirement);
+        assertEquals(StorageOperationStatus.OK, result);
+    }
+
+    @Test
+    void test_addComponentInstanceOutput() {
+        final NodeTemplateOperation testInstance = Mockito.spy(new NodeTemplateOperation());
+        final Component component = new Resource();
+        component.setUniqueId(COMPONENT_ID);
+
+        final String componentInstanceId = "requirementOwnerId";
+
+        final ComponentInstanceOutput instanceOutput = new ComponentInstanceOutput();
+
+        doReturn(StorageOperationStatus.OK).when((BaseOperation) testInstance)
+            .addToscaDataDeepElementToToscaElement(eq(COMPONENT_ID), eq(EdgeLabelEnum.INST_OUTPUTS), eq(VertexTypeEnum.INST_OUTPUTS),
+                ArgumentMatchers.any(ComponentInstanceOutput.class), ArgumentMatchers.anyList(), eq(JsonPresentationFields.NAME));
+
+        final StorageOperationStatus result = testInstance.addComponentInstanceOutput(component, componentInstanceId, instanceOutput);
+        assertNotNull(result);
+        assertEquals(StorageOperationStatus.OK, result);
+        verify((BaseOperation) testInstance, times(1))
+            .addToscaDataDeepElementToToscaElement(eq(COMPONENT_ID), eq(EdgeLabelEnum.INST_OUTPUTS), eq(VertexTypeEnum.INST_OUTPUTS),
+                ArgumentMatchers.any(ComponentInstanceOutput.class), ArgumentMatchers.anyList(), eq(JsonPresentationFields.NAME));
+    }
+
+    @Test
+    void test_updateComponentInstanceAttributes() {
+        final NodeTemplateOperation testInstance = Mockito.spy(new NodeTemplateOperation());
+        final Component component = new Resource();
+        component.setUniqueId(COMPONENT_ID);
+
+        final String componentInstanceId = "requirementOwnerId";
+
+        final ComponentInstanceAttribute instanceAttribute = new ComponentInstanceAttribute();
+        final List<ComponentInstanceAttribute> attributes = new ArrayList<>();
+        attributes.add(instanceAttribute);
+
+        doReturn(StorageOperationStatus.OK).when((BaseOperation) testInstance)
+            .updateToscaDataDeepElementsOfToscaElement(eq(COMPONENT_ID), eq(EdgeLabelEnum.INST_ATTRIBUTES), eq(VertexTypeEnum.INST_ATTRIBUTES),
+                eq(attributes), ArgumentMatchers.anyList(), eq(JsonPresentationFields.NAME));
+
+        final StorageOperationStatus result = testInstance.updateComponentInstanceAttributes(component, componentInstanceId, attributes);
+        assertNotNull(result);
+        assertEquals(StorageOperationStatus.OK, result);
+        verify((BaseOperation) testInstance, times(1))
+            .updateToscaDataDeepElementsOfToscaElement(eq(COMPONENT_ID), eq(EdgeLabelEnum.INST_ATTRIBUTES), eq(VertexTypeEnum.INST_ATTRIBUTES),
+                eq(attributes), ArgumentMatchers.anyList(), eq(JsonPresentationFields.NAME));
+    }
+
+    @Test
+    void test_updateComponentInstanceAttribute() {
+        final NodeTemplateOperation testInstance = Mockito.spy(new NodeTemplateOperation());
+        final Component component = new Resource();
+        component.setUniqueId(COMPONENT_ID);
+
+        final String componentInstanceId = "requirementOwnerId";
+
+        final ComponentInstanceAttribute instanceAttribute = new ComponentInstanceAttribute();
+
+        doReturn(StorageOperationStatus.OK).when((BaseOperation) testInstance)
+            .updateToscaDataDeepElementOfToscaElement(eq(COMPONENT_ID), eq(EdgeLabelEnum.INST_ATTRIBUTES), eq(VertexTypeEnum.INST_ATTRIBUTES),
+                eq(instanceAttribute), ArgumentMatchers.anyList(), eq(JsonPresentationFields.NAME));
+
+        final StorageOperationStatus result = testInstance.updateComponentInstanceAttribute(component, componentInstanceId, instanceAttribute);
+        assertNotNull(result);
+        assertEquals(StorageOperationStatus.OK, result);
+        verify((BaseOperation) testInstance, times(1))
+            .updateToscaDataDeepElementOfToscaElement(eq(COMPONENT_ID), eq(EdgeLabelEnum.INST_ATTRIBUTES), eq(VertexTypeEnum.INST_ATTRIBUTES),
+                eq(instanceAttribute), ArgumentMatchers.anyList(), eq(JsonPresentationFields.NAME));
+    }
+
+    @Test
+    void test_updateComponentInstanceOutputs() {
+        final NodeTemplateOperation testInstance = Mockito.spy(new NodeTemplateOperation());
+        final Component component = new Resource();
+        component.setUniqueId(COMPONENT_ID);
+
+        final String componentInstanceId = "requirementOwnerId";
+
+        List<ComponentInstanceOutput> componentInstanceOutputList = new ArrayList<>();
+        ComponentInstanceOutput instanceOutput = new ComponentInstanceOutput();
+        componentInstanceOutputList.add(instanceOutput);
+
+        doReturn(StorageOperationStatus.OK).when((BaseOperation) testInstance)
+            .updateToscaDataDeepElementsOfToscaElement(eq(COMPONENT_ID), eq(EdgeLabelEnum.INST_OUTPUTS), eq(VertexTypeEnum.INST_OUTPUTS),
+                eq(componentInstanceOutputList), ArgumentMatchers.anyList(), eq(JsonPresentationFields.NAME));
+
+        final StorageOperationStatus result = testInstance.updateComponentInstanceOutputs(component, componentInstanceId, componentInstanceOutputList);
+        assertNotNull(result);
+        assertEquals(StorageOperationStatus.OK, result);
+        verify((BaseOperation) testInstance, times(1))
+            .updateToscaDataDeepElementsOfToscaElement(eq(COMPONENT_ID), eq(EdgeLabelEnum.INST_OUTPUTS), eq(VertexTypeEnum.INST_OUTPUTS),
+                eq(componentInstanceOutputList), ArgumentMatchers.anyList(), eq(JsonPresentationFields.NAME));
+    }
 
     private ComponentInstance createCompInstance() {
         ComponentInstance componentInstance = new ComponentInstance();
@@ -345,6 +446,7 @@ public class NodeTemplateOperationTest extends ModelTestBase {
         componentInstance.setName(id);
         return componentInstance;
     }
+
     private static void buildRequirementDataDefinition() {
         buildRequirement();
         fulfilledRequirement = new HashMap<>();
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/TopologyTemplateOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/TopologyTemplateOperationTest.java
index 436af94c1c..dc5e2fd5ea 100644
--- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/TopologyTemplateOperationTest.java
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/TopologyTemplateOperationTest.java
@@ -55,6 +55,9 @@ import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 @RunWith(MockitoJUnitRunner.class)
@@ -148,6 +151,25 @@ public class TopologyTemplateOperationTest {
     }
 
     @Test
+    public void testSetOutputsFromGraph() {
+        final GraphVertex containerVertex = new GraphVertex();
+        final ComponentParametersView filter = new ComponentParametersView(true);
+        filter.setIgnoreOutputs(false);
+        final String componentName = "componentName";
+        final String componentId = UniqueIdBuilder.buildResourceUniqueId();
+        containerVertex.setVertex(Mockito.mock(JanusGraphVertex.class));
+        containerVertex.setJsonMetadataField(JsonPresentationFields.NAME, componentName);
+        containerVertex.setUniqueId(componentId);
+        containerVertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE);
+        doReturn(Either.right(JanusGraphOperationStatus.GENERAL_ERROR)).when(janusGraphDao)
+            .getChildVertex(any(GraphVertex.class), any(EdgeLabelEnum.class), any(JsonParseFlagEnum.class));
+        final Either<ToscaElement, StorageOperationStatus> storageOperationStatus
+            = topologyTemplateOperation.getToscaElement(containerVertex, filter);
+        assertThat(storageOperationStatus).isEqualTo(Either.right(StorageOperationStatus.GENERAL_ERROR));
+        verify(janusGraphDao, times(1)).getChildVertex(any(GraphVertex.class), any(EdgeLabelEnum.class), any(JsonParseFlagEnum.class));
+    }
+
+    @Test
     public void testUpdateDistributionStatus() {
         Either<GraphVertex, StorageOperationStatus> result;
         String uniqueId = "uniqueId";
@@ -176,7 +198,7 @@ public class TopologyTemplateOperationTest {
             JanusGraphOperationStatus.OK);
         when(janusGraphDao.updateVertex(graphVertex)).thenReturn(Either.left(graphVertex));
         result = topologyTemplateOperation.updateDistributionStatus(uniqueId, user, DistributionStatusEnum.DISTRIBUTED);
-        assertThat(result.isLeft());
+        assertThat(result.isLeft()).isTrue();
     }
 
     @SuppressWarnings("unchecked")
@@ -195,7 +217,7 @@ public class TopologyTemplateOperationTest {
         int counter = 0;
         Either<GraphVertex, JanusGraphOperationStatus> toscaDataVertexRes = Either.right(
             JanusGraphOperationStatus.NOT_FOUND);
-        when(janusGraphDao.getChildVertex(eq(componentV), eq(EdgeLabelEnum.POLICIES), eq(JsonParseFlagEnum.ParseJson))).thenReturn(toscaDataVertexRes);
+        when(janusGraphDao.getChildVertex(componentV, EdgeLabelEnum.POLICIES, JsonParseFlagEnum.ParseJson)).thenReturn(toscaDataVertexRes);
         Either<GraphVertex, JanusGraphOperationStatus> createVertex = Either.left(dataV);
         when(janusGraphDao.createVertex(any(GraphVertex.class))).thenReturn(createVertex);
         when(janusGraphDao.createEdge(any(JanusGraphVertex.class), any(JanusGraphVertex.class), any(EdgeLabelEnum.class), any(HashMap.class))).thenReturn(status);
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaOperationFacadeTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaOperationFacadeTest.java
index 971f4f79ab..621b275a67 100644
--- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaOperationFacadeTest.java
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaOperationFacadeTest.java
@@ -48,6 +48,7 @@ import org.openecomp.sdc.be.dao.jsongraph.HealingJanusGraphDao;
 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
+import org.openecomp.sdc.be.datatypes.elements.AttributeDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition;
 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
@@ -56,9 +57,13 @@ import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
 import org.openecomp.sdc.be.datatypes.enums.PromoteVersionEnum;
 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
+import org.openecomp.sdc.be.model.AttributeDefinition;
 import org.openecomp.sdc.be.model.Component;
 import org.openecomp.sdc.be.model.ComponentInstance;
+import org.openecomp.sdc.be.model.ComponentInstanceAttribute;
+import org.openecomp.sdc.be.model.ComponentInstanceOutput;
 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
+import org.openecomp.sdc.be.model.OutputDefinition;
 import org.openecomp.sdc.be.model.Resource;
 import org.openecomp.sdc.be.model.LifecycleStateEnum;
 import org.openecomp.sdc.be.model.ComponentParametersView;
@@ -90,8 +95,12 @@ import java.util.Collections;
 import java.util.Arrays;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -122,7 +131,7 @@ public class ToscaOperationFacadeTest {
     private TopologyTemplateOperation topologyTemplateOperationMock;
 
     @Mock
-    private NodeTypeOperation nodeTypeOperation;
+    private NodeTypeOperation nodeTypeOperationMock;
 
     @Mock
     private NodeTemplateOperation nodeTemplateOperationMock;
@@ -369,7 +378,7 @@ public class ToscaOperationFacadeTest {
         when(janusGraphDaoMock.getVertexById(id, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex));
         when(janusGraphDaoMock.getParentVertex(graphVertex, EdgeLabelEnum.VERSION, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex));
         when(topologyTemplateOperationMock.deleteToscaElement(graphVertex)).thenReturn(Either.left(toscaElement));
-        when(nodeTypeOperation.createToscaElement(any(ToscaElement.class))).thenReturn(Either.left(nodeType));
+        when(nodeTypeOperationMock.createToscaElement(any(ToscaElement.class))).thenReturn(Either.left(nodeType));
         when(janusGraphDaoMock.getVertexById(null, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex));
         when(janusGraphDaoMock.createEdge(graphVertex, graphVertex, EdgeLabelEnum.VERSION, null)).thenReturn(
             JanusGraphOperationStatus.OK);
@@ -397,7 +406,7 @@ public class ToscaOperationFacadeTest {
         component.setUniqueId(id);
         GraphVertex graphVertex = getTopologyTemplateVertex();
         when(janusGraphDaoMock.getVertexById(id, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex));
-        when(nodeTypeOperation.markComponentToDelete(graphVertex)).thenReturn(Either.left(graphVertex));
+        when(nodeTypeOperationMock.markComponentToDelete(graphVertex)).thenReturn(Either.left(graphVertex));
         result = testInstance.markComponentToDelete(component);
         assertEquals(result, StorageOperationStatus.OK);
     }
@@ -484,7 +493,8 @@ public class ToscaOperationFacadeTest {
         List<ToscaElement> toscaEleList = new ArrayList<>();
         ToscaElement toscaElement = getToscaElementForTest();
         toscaEleList.add(toscaElement);
-        when(nodeTypeOperation.getFollowedComponent(userId, lifecycleStates, lastStateStates, componentType)).thenReturn(Either.left(toscaEleList));
+        when(nodeTypeOperationMock.getFollowedComponent(userId, lifecycleStates, lastStateStates, componentType))
+            .thenReturn(Either.left(toscaEleList));
         result = testInstance.getFollowed(userId, lifecycleStates, lastStateStates, componentType);
         assertTrue(result.isLeft());
         assertEquals(1, result.left().value().size());
@@ -806,11 +816,226 @@ public class ToscaOperationFacadeTest {
     }
 
     @Test
-    public void associateRequirementsToServiceSuccessTest(){
+    public void associateRequirementsToServiceSuccessTest() {
         StorageOperationStatus result = associateRequirementsToServiceWithStatus(StorageOperationStatus.OK);
         assertTrue(result == StorageOperationStatus.OK);
     }
 
+    @Test
+    public void test_addOutputsToComponent() {
+        final GraphVertex graphVertex = getTopologyTemplateVertex();
+        final String componentId = "componentId";
+
+        doReturn(Either.left(graphVertex)).when(janusGraphDaoMock).getVertexById(componentId, JsonParseFlagEnum.NoParse);
+        doReturn(StorageOperationStatus.OK).when(topologyTemplateOperationMock)
+            .addToscaDataToToscaElement(
+                any(GraphVertex.class), eq(EdgeLabelEnum.OUTPUTS), eq(VertexTypeEnum.OUTPUTS), anyMap(), eq(JsonPresentationFields.NAME));
+
+        final Map<String, OutputDefinition> outputs = new HashMap<>();
+        final OutputDefinition outputDefinition = new OutputDefinition();
+        outputs.put("mock", outputDefinition);
+        final Either<List<OutputDefinition>, StorageOperationStatus> result = testInstance.addOutputsToComponent(outputs, componentId);
+        assertNotNull(result);
+        assertTrue(result.isLeft());
+        assertFalse(result.left().value().isEmpty());
+        assertThat(result.left().value().get(0)).isInstanceOf(OutputDefinition.class);
+        verify(janusGraphDaoMock, times(1)).getVertexById(componentId, JsonParseFlagEnum.NoParse);
+        verify(topologyTemplateOperationMock, times(1)).addToscaDataToToscaElement(
+            any(GraphVertex.class), eq(EdgeLabelEnum.OUTPUTS), eq(VertexTypeEnum.OUTPUTS), anyMap(), eq(JsonPresentationFields.NAME));
+    }
+
+    @Test
+    public void test_addComponentInstanceOutputsToComponent_updateComponentInstanceOutput() {
+        final Component component = new Resource();
+        component.setUniqueId(COMPONENT_ID);
+        final Map<String, List<ComponentInstanceOutput>> map = new HashMap<>();
+        final List<ComponentInstanceOutput> componentInstanceOutputList = new ArrayList<>();
+        final ComponentInstanceOutput componentInstanceOutput = new ComponentInstanceOutput();
+        componentInstanceOutput.setComponentInstanceId(COMPONENT_ID);
+        componentInstanceOutput.setComponentInstanceName(COMPONENT_ID);
+        componentInstanceOutput.setName(COMPONENT_ID);
+        componentInstanceOutputList.add(componentInstanceOutput);
+        map.put("mock", componentInstanceOutputList);
+        component.setComponentInstancesOutputs(map);
+
+        doReturn(StorageOperationStatus.OK).when(nodeTemplateOperationMock)
+            .updateComponentInstanceOutput(any(Component.class), anyString(), any(ComponentInstanceOutput.class));
+
+        final Either<Map<String, List<ComponentInstanceOutput>>, StorageOperationStatus> result
+            = testInstance.addComponentInstanceOutputsToComponent(component, map);
+        assertNotNull(result);
+        assertTrue(result.isLeft());
+        assertFalse(result.left().value().isEmpty());
+        assertSame(result.left().value(), map);
+        verify(nodeTemplateOperationMock, times(1))
+            .updateComponentInstanceOutput(any(Component.class), anyString(), any(ComponentInstanceOutput.class));
+
+    }
+
+    @Test
+    public void test_addComponentInstanceOutputsToComponent_addComponentInstanceOutput() {
+        final Component component = new Resource();
+        component.setUniqueId(COMPONENT_ID);
+        Map<String, List<ComponentInstanceOutput>> map = new HashMap<>();
+        List<ComponentInstanceOutput> componentInstanceOutputList = new ArrayList<>();
+        ComponentInstanceOutput componentInstanceOutput = new ComponentInstanceOutput();
+        componentInstanceOutput.setComponentInstanceId(COMPONENT_ID);
+        componentInstanceOutput.setComponentInstanceName(COMPONENT_ID);
+        componentInstanceOutput.setName(COMPONENT_ID);
+        componentInstanceOutputList.add(componentInstanceOutput);
+        map.put("mock", componentInstanceOutputList);
+        component.setComponentInstancesOutputs(map);
+
+        map = new HashMap<>();
+        componentInstanceOutputList = new ArrayList<>();
+        componentInstanceOutput = new ComponentInstanceOutput();
+        componentInstanceOutput.setComponentInstanceId("mock");
+        componentInstanceOutput.setComponentInstanceName("mock");
+        componentInstanceOutput.setName("mock");
+        componentInstanceOutputList.add(componentInstanceOutput);
+        map.put("mock", componentInstanceOutputList);
+
+        final Either<Map<String, List<ComponentInstanceOutput>>, StorageOperationStatus> result = testInstance
+            .addComponentInstanceOutputsToComponent(component, map);
+        assertNotNull(result);
+        assertTrue(result.isRight());
+    }
+
+    @Test
+    public void test_addComponentInstanceAttributesToComponent() {
+        final Component component = new Resource();
+        component.setUniqueId(COMPONENT_ID);
+        Map<String, List<ComponentInstanceAttribute>> map = new HashMap<>();
+        List<ComponentInstanceAttribute> componentInstanceOutputList = new ArrayList<>();
+        ComponentInstanceAttribute componentInstanceAttribute = new ComponentInstanceAttribute();
+        componentInstanceAttribute.setComponentInstanceId(COMPONENT_ID);
+        componentInstanceAttribute.setUniqueId(COMPONENT_ID);
+        componentInstanceOutputList.add(componentInstanceAttribute);
+        map.put("mock", componentInstanceOutputList);
+        component.setComponentInstancesAttributes(map);
+
+        doReturn(StorageOperationStatus.OK).when(nodeTemplateOperationMock)
+            .updateComponentInstanceAttribute(any(Component.class), anyString(), any(ComponentInstanceAttribute.class));
+
+        final Either<Map<String, List<ComponentInstanceAttribute>>, StorageOperationStatus> result
+            = testInstance.addComponentInstanceAttributesToComponent(component, map);
+
+        assertNotNull(result);
+        assertTrue(result.isLeft());
+        assertFalse(result.left().value().isEmpty());
+        assertSame(result.left().value(), map);
+        verify(nodeTemplateOperationMock, times(1))
+            .updateComponentInstanceAttribute(any(Component.class), anyString(), any(ComponentInstanceAttribute.class));
+    }
+
+    @Test
+    public void test_updateAttributeOfComponent_success() {
+        final GraphVertex graphVertex = getTopologyTemplateVertex();
+        final String componentId = "componentId";
+        final Component component = new Resource();
+        component.setUniqueId(COMPONENT_ID);
+        doReturn(StorageOperationStatus.OK).when(nodeTypeOperationMock).updateToscaDataOfToscaElement(
+            anyString(), eq(EdgeLabelEnum.ATTRIBUTES), eq(VertexTypeEnum.ATTRIBUTES), any(AttributeDefinition.class),
+            eq(JsonPresentationFields.NAME));
+        doReturn(Either.left(graphVertex)).when(janusGraphDaoMock).getVertexById(eq(componentId), any(JsonParseFlagEnum.class));
+
+        final ToscaElement toscaElement = getToscaElementForTest();
+        final Map<String, AttributeDataDefinition> attributes = new HashMap<>();
+        final AttributeDefinition attributeDefinition = new AttributeDefinition();
+        attributeDefinition.setName("mock");
+        attributes.put("mock", attributeDefinition);
+        toscaElement.setAttributes(attributes);
+        doReturn(Either.left(toscaElement)).when(topologyTemplateOperationMock)
+            .getToscaElement(ArgumentMatchers.eq(graphVertex), any(ComponentParametersView.class));
+
+        final Either<AttributeDefinition, StorageOperationStatus> result
+            = testInstance.updateAttributeOfComponent(component, attributeDefinition);
+        assertNotNull(result);
+    }
+
+    @Test
+    public void test_updateAttributeOfComponent_isNotPresent() {
+        final GraphVertex graphVertex = getTopologyTemplateVertex();
+        final String componentId = "componentId";
+        final Component component = new Resource();
+        component.setUniqueId(COMPONENT_ID);
+        doReturn(StorageOperationStatus.OK).when(nodeTypeOperationMock).updateToscaDataOfToscaElement(
+            anyString(), eq(EdgeLabelEnum.ATTRIBUTES), eq(VertexTypeEnum.ATTRIBUTES), any(AttributeDefinition.class),
+            eq(JsonPresentationFields.NAME));
+        doReturn(Either.left(graphVertex)).when(janusGraphDaoMock).getVertexById(eq(componentId), any(JsonParseFlagEnum.class));
+
+        final ToscaElement toscaElement = getToscaElementForTest();
+        final Map<String, AttributeDataDefinition> attributes = new HashMap<>();
+        final AttributeDefinition attributeDefinition = new AttributeDefinition();
+        attributeDefinition.setName("mock");
+        attributes.put("mock", attributeDefinition);
+        toscaElement.setAttributes(attributes);
+        doReturn(Either.left(toscaElement)).when(topologyTemplateOperationMock)
+            .getToscaElement(ArgumentMatchers.eq(graphVertex), any(ComponentParametersView.class));
+
+        final AttributeDefinition attributeDefinitionOneMore = new AttributeDefinition();
+        attributeDefinitionOneMore.setName("Anothermock");
+
+        final Either<AttributeDefinition, StorageOperationStatus> result
+            = testInstance.updateAttributeOfComponent(component, attributeDefinitionOneMore);
+        assertNotNull(result);
+    }
+
+    @Test
+    public void test_updateComponentInstanceAttributes() {
+        final GraphVertex graphVertex = getTopologyTemplateVertex();
+        final String componentId = "componentId";
+        final Component component = new Resource();
+        component.setUniqueId(COMPONENT_ID);
+
+        final List<ComponentInstanceAttribute> attributes = new ArrayList<>();
+        final ComponentInstanceAttribute attributeDefinition = new ComponentInstanceAttribute();
+        attributeDefinition.setName("mock");
+        attributes.add(attributeDefinition);
+
+        doReturn(StorageOperationStatus.OK).when(nodeTemplateOperationMock).updateComponentInstanceAttributes(component, componentId, attributes);
+
+        final StorageOperationStatus result = testInstance.updateComponentInstanceAttributes(component, componentId, attributes);
+        assertNotNull(result);
+        assertEquals(StorageOperationStatus.OK, result);
+        verify(nodeTemplateOperationMock, times(1)).updateComponentInstanceAttributes(component, componentId, attributes);
+    }
+
+    @Test
+    public void test_updateComponentInstanceOutputs() {
+        final GraphVertex graphVertex = getTopologyTemplateVertex();
+        final String componentId = "componentId";
+        final Component component = new Resource();
+        component.setUniqueId(COMPONENT_ID);
+
+        final List<ComponentInstanceOutput> list = new ArrayList<>();
+        final ComponentInstanceOutput output = new ComponentInstanceOutput();
+        output.setName("mock");
+        list.add(output);
+
+        doReturn(StorageOperationStatus.OK).when(nodeTemplateOperationMock).updateComponentInstanceOutputs(component, componentId, list);
+
+        final StorageOperationStatus result = testInstance.updateComponentInstanceOutputs(component, componentId, list);
+        assertNotNull(result);
+        assertEquals(StorageOperationStatus.OK, result);
+        verify(nodeTemplateOperationMock, times(1)).updateComponentInstanceOutputs(component, componentId, list);
+    }
+
+    @Test
+    public void test_deleteOutputOfResource() {
+        final Component component = new Resource();
+        component.setUniqueId(COMPONENT_ID);
+
+        doReturn(StorageOperationStatus.OK).when(nodeTypeOperationMock)
+            .deleteToscaDataElement(anyString(), eq(EdgeLabelEnum.OUTPUTS), eq(VertexTypeEnum.OUTPUTS), anyString(), eq(JsonPresentationFields.NAME));
+
+        final StorageOperationStatus result = testInstance.deleteOutputOfResource(component, "mock");
+        assertNotNull(result);
+        assertEquals(StorageOperationStatus.OK, result);
+        verify(nodeTypeOperationMock, times(1))
+            .deleteToscaDataElement(anyString(), eq(EdgeLabelEnum.OUTPUTS), eq(VertexTypeEnum.OUTPUTS), anyString(), eq(JsonPresentationFields.NAME));
+    }
+
     private StorageOperationStatus associateRequirementsToServiceWithStatus(StorageOperationStatus status) {
         Map<String, ListRequirementDataDefinition> requirementsMap = new HashedMap();
         String componentId = "componentid";
@@ -819,7 +1044,7 @@ public class ToscaOperationFacadeTest {
         requirementsMap.put("requirements1", listRequirementDataDefinition1);
 
         GraphVertex vertex;
-        if(status == StorageOperationStatus.OK){
+        if (status == StorageOperationStatus.OK) {
             vertex = getTopologyTemplateVertex();
         } else {
             vertex = getNodeTypeVertex();
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/ModelConverterTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/ModelConverterTest.java
index 740d148a79..81635e20e0 100644
--- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/ModelConverterTest.java
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/ModelConverterTest.java
@@ -29,14 +29,25 @@
  */
 package org.openecomp.sdc.be.model.jsonjanusgraph.utils;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
 import org.mockito.junit.MockitoJUnitRunner;
 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
+import org.openecomp.sdc.be.datatypes.elements.AttributeDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.MapAttributesDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition;
 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
+import org.openecomp.sdc.be.model.AttributeDefinition;
+import org.openecomp.sdc.be.model.ComponentInstance;
+import org.openecomp.sdc.be.model.ComponentInstanceOutput;
+import org.openecomp.sdc.be.model.OutputDefinition;
 import org.openecomp.sdc.be.model.Resource;
 import org.openecomp.sdc.be.model.Service;
 import org.openecomp.sdc.be.model.Component;
@@ -47,6 +58,8 @@ import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElementTypeEnum;
 import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 
@@ -107,8 +120,7 @@ public class ModelConverterTest {
     }
 
     @Test
-    public void testConvertFromToscaElementResourceType()
-    {
+    public void testConvertFromToscaElementResourceType() {
         TopologyTemplate topologyTemplate = new TopologyTemplate();
         topologyTemplate.setComponentType(ComponentTypeEnum.RESOURCE);
         topologyTemplate.setResourceType(ResourceTypeEnum.PNF);
@@ -117,8 +129,44 @@ public class ModelConverterTest {
     }
 
     @Test
-    public void testIsAtomicComponent()
-    {
+    public void testConvertFromToscaElementResourceOutputs() {
+        final TopologyTemplate topologyTemplate = new TopologyTemplate();
+        topologyTemplate.setComponentType(ComponentTypeEnum.RESOURCE);
+        final OutputDefinition outputDefinition = new OutputDefinition();
+        final Map<String, AttributeDataDefinition> map = new HashMap<>();
+        map.put("mock", outputDefinition);
+        topologyTemplate.setOutputs(map);
+        final Resource resource = test.convertFromToscaElement(topologyTemplate);
+        assertNotNull(resource.getOutputs());
+        assertFalse(resource.getOutputs().isEmpty());
+    }
+
+    @Test
+    public void testConvertFromToscaElementResourceComponentInstancesOutputs() {
+        final TopologyTemplate topologyTemplate = new TopologyTemplate();
+        topologyTemplate.setComponentType(ComponentTypeEnum.RESOURCE);
+
+        final Map<String, MapAttributesDataDefinition> instOutputs = new HashMap<>();
+        final MapAttributesDataDefinition mapAttributesDataDefinition = new MapAttributesDataDefinition();
+        final AttributeDefinition attributeDefinition = new AttributeDefinition();
+        final Map<String, AttributeDataDefinition> mapToscaDataDefinition = new HashMap<>();
+        mapToscaDataDefinition.put("mock", attributeDefinition);
+        mapAttributesDataDefinition.setMapToscaDataDefinition(mapToscaDataDefinition);
+        instOutputs.put("mock", mapAttributesDataDefinition);
+        topologyTemplate.setInstOutputs(instOutputs);
+
+        final Map<String, ComponentInstanceDataDefinition> componentInstanceDataDefinitionMap = new HashMap<>();
+        componentInstanceDataDefinitionMap.put("mock", new ComponentInstance());
+        topologyTemplate.setComponentInstances(componentInstanceDataDefinitionMap);
+
+        final Resource resource = test.convertFromToscaElement(topologyTemplate);
+        assertNotNull(resource);
+        assertNotNull(resource.getComponentInstancesOutputs());
+        assertFalse(resource.getComponentInstancesOutputs().isEmpty());
+    }
+
+    @Test
+    public void testIsAtomicComponent() {
         Resource component = new Resource();
         component.setComponentType(ComponentTypeEnum.RESOURCE);
         boolean result = test.isAtomicComponent(component);
diff --git a/common-be/src/test/java/org/openecomp/sdc/be/datatypes/elements/GetOutputValueDataDefinitionTest.java b/common-be/src/test/java/org/openecomp/sdc/be/datatypes/elements/GetOutputValueDataDefinitionTest.java
new file mode 100644
index 0000000000..6c975bd8a2
--- /dev/null
+++ b/common-be/src/test/java/org/openecomp/sdc/be/datatypes/elements/GetOutputValueDataDefinitionTest.java
@@ -0,0 +1,40 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2021, Nordix Foundation. 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.datatypes.elements;
+
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import java.util.HashMap;
+import org.junit.jupiter.api.Test;
+
+class GetOutputValueDataDefinitionTest {
+
+    private final GetOutputValueDataDefinition testInstance = new GetOutputValueDataDefinition();
+
+    @Test
+    void testCtor() throws Exception {
+        assertThat(testInstance, instanceOf(GetOutputValueDataDefinition.class));
+        assertThat(new GetOutputValueDataDefinition(new HashMap<>()), instanceOf(GetOutputValueDataDefinition.class));
+        assertThat(new GetOutputValueDataDefinition(testInstance), instanceOf(GetOutputValueDataDefinition.class));
+    }
+
+}