Sync Integ to Master

Change-Id: I71e3acc26fa612127756ac04073a522b9cc6cd74
Issue-ID: SDC-977
Signed-off-by: Gitelman, Tal (tg851x) <tg851x@intl.att.com>

21 files changed, 2184 insertions, 270 deletions

diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/config/ModelOperationsSpringConfig.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/config/ModelOperationsSpringConfig.java
new file mode 100644
index 0000000000..1215b5fc6f
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/config/ModelOperationsSpringConfig.java
@@ -0,0 +1,9 @@
+package org.openecomp.sdc.be.model.config;
+
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@ComponentScan({"org.openecomp.sdc.be.model.jsontitan.operations","org.openecomp.sdc.be.model.jsontitan.utils"})
+public class ModelOperationsSpringConfig {
+}
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ExternalReferencesOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ExternalReferencesOperationTest.java
new file mode 100644
index 0000000000..c0ba256957
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ExternalReferencesOperationTest.java
@@ -0,0 +1,178 @@
+package org.openecomp.sdc.be.model.jsontitan.operations;
+
+import fj.data.Either;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.openecomp.sdc.be.dao.api.ActionStatus;
+import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
+import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
+import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
+import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
+import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
+import org.openecomp.sdc.be.datatypes.elements.MapComponentInstanceExternalRefs;
+import org.openecomp.sdc.be.model.ModelTestBase;
+import org.openecomp.sdc.be.model.jsontitan.utils.GraphTestUtils;
+import org.openecomp.sdc.be.model.jsontitan.utils.IdMapper;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import javax.annotation.Resource;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.when;
+
+/**
+ * Created by yavivi on 26/01/2018.
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration("classpath:application-context-test.xml")
+public class ExternalReferencesOperationTest extends ModelTestBase {
+
+    @Resource
+    private ExternalReferencesOperation externalReferenceOperation;
+
+    @Resource
+    private TitanDao titanDao;
+
+    private boolean isInitialized;
+
+    private GraphVertex serviceVertex;
+
+    private String serviceVertexUuid;
+    private static final String COMPONENT_ID = "ci-MyComponentName";
+
+    private static final String MONITORING_OBJECT_TYPE = "monitoring";
+    private static final String WORKFLOW_OBJECT_TYPE = "workflow";
+    private static final String REF_1 = "ref1";
+    private static final String REF_2 = "ref2";
+    private static final String REF_3 = "ref3";
+    private static final String REF_4 = "ref4";
+    private static final String REF_5 = "ref5";
+
+    //workflow
+    private static final String REF_6 = "ref6";
+
+    private IdMapper idMapper;
+
+    @BeforeClass
+    public static void initTest(){
+        ModelTestBase.init();
+    }
+
+    @Before
+    public void beforeTest() {
+        idMapper = Mockito.mock(IdMapper.class);
+        this.externalReferenceOperation.setIdMapper(idMapper);
+        when(idMapper.mapComponentNameToUniqueId(Mockito.anyString(), Mockito.any(GraphVertex.class))).thenReturn(COMPONENT_ID);
+        if (!isInitialized) {
+            GraphTestUtils.clearGraph(titanDao);
+            initGraphForTest();
+            isInitialized = true;
+        }
+    }
+
+    @Test
+    public void testAddComponentInstanceExternalRef(){
+        Either<String, ActionStatus> addResult = externalReferenceOperation.addExternalReference(this.serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_4);
+        assertThat(addResult.isLeft()).isEqualTo(true);
+
+        //commit changes to titan
+        final TitanOperationStatus commit = this.titanDao.commit();
+        assertThat(commit).isEqualTo(TitanOperationStatus.OK);
+
+        assertThat(getServiceExternalRefs()).contains(REF_1, REF_2, REF_3, REF_4);
+    }
+
+    @Test
+    public void testGetComponentInstanceExternalRef(){
+        assertThat(externalReferenceOperation.getExternalReferences(this.serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE).left().value()).contains(REF_1, REF_2, REF_3, REF_5);
+        assertThat(externalReferenceOperation.getExternalReferences(this.serviceVertexUuid, COMPONENT_ID, WORKFLOW_OBJECT_TYPE).left().value()).containsExactly(REF_6);
+    }
+
+    @Test
+    public void testGetComponentInstanceExternalRefForNonExistingObjectId(){
+        assertThat(externalReferenceOperation.getExternalReferences(this.serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE).left().value()).contains(REF_1, REF_2, REF_3, REF_5);
+        Either<List<String>, ActionStatus> getResult = externalReferenceOperation.getExternalReferences(this.serviceVertexUuid, COMPONENT_ID, "FAKE_OBJECT_TYPE");
+        assertThat(getResult.left().value()).isEmpty();
+    }
+
+    @Test
+    public void testDeleteComponentInstanceExternalRef(){
+        //Test the precondition
+        assertThat(getServiceExternalRefs()).contains(REF_5);
+
+        //Remove REF 5
+        Either<String, ActionStatus> deleteStatus = externalReferenceOperation.deleteExternalReference(this.serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_5);
+        assertThat(deleteStatus.isLeft()).isEqualTo(true);
+
+        //commit changes to titan
+        final TitanOperationStatus commit = this.titanDao.commit();
+        assertThat(commit).isEqualTo(TitanOperationStatus.OK);
+
+        //Check that ref does not exist anymore
+        assertThat(getServiceExternalRefs()).doesNotContain(REF_5).contains(REF_1, REF_2, REF_3);
+    }
+
+    @Test
+    public void testUpdateComponentInstanceExternalRef(){
+        //Test the precondition
+        assertThat(getServiceExternalRefs()).contains(REF_5).doesNotContain(REF_4);
+
+        //Update REF 5 with REF_4
+        Either<String, ActionStatus> updateResult = externalReferenceOperation.updateExternalReference(this.serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_5, REF_4);
+
+        assertThat(updateResult.isLeft()).isEqualTo(true);
+
+        //commit changes to titan
+        final TitanOperationStatus commit = this.titanDao.commit();
+        assertThat(commit).isEqualTo(TitanOperationStatus.OK);
+
+        //Check that ref does not exist anymore
+        assertThat(getServiceExternalRefs()).doesNotContain(REF_5).contains(REF_1, REF_2, REF_3, REF_4);
+    }
+
+    private List<String> getServiceExternalRefs(){
+        //Get service vertex
+        final Either<GraphVertex, TitanOperationStatus> externalRefsVertexResult = this.titanDao.getChildVertex(this.serviceVertex, EdgeLabelEnum.EXTERNAL_REFS, JsonParseFlagEnum.ParseJson);
+        assertThat(externalRefsVertexResult.isLeft()).isEqualTo(true);
+
+        GraphVertex externalRefVertex = externalRefsVertexResult.left().value();
+
+        //Get the full map
+        Map<String, MapComponentInstanceExternalRefs> componentInstancesMap = (Map<String, MapComponentInstanceExternalRefs>) externalRefVertex.getJson();
+        assertThat(componentInstancesMap).isNotNull();
+
+        //Get Map of external refs by object type
+        final MapComponentInstanceExternalRefs mapComponentInstanceExternalRefs = componentInstancesMap.get(COMPONENT_ID);
+
+        //Get List of references
+        //final List<String> externalRefsByObjectType = mapComponentInstanceExternalRefs.externalRefsByObjectType(objectType);
+        final List<String> externalRefsByObjectType = mapComponentInstanceExternalRefs.getExternalRefsByObjectType(MONITORING_OBJECT_TYPE);
+
+        return externalRefsByObjectType;
+    }
+
+    private void initGraphForTest() {
+        //create a service and add 1 ref
+        this.serviceVertex = GraphTestUtils.createServiceVertex(titanDao, new HashMap<>());
+        this.serviceVertexUuid = this.serviceVertex.getUniqueId();
+
+        //monitoring references
+        externalReferenceOperation.addExternalReference(serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_1);
+        externalReferenceOperation.addExternalReference(serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_2);
+        externalReferenceOperation.addExternalReference(serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_3);
+        externalReferenceOperation.addExternalReference(serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_5);
+
+        //workflow references
+        externalReferenceOperation.addExternalReference(serviceVertexUuid, COMPONENT_ID, WORKFLOW_OBJECT_TYPE, REF_6);
+
+        final TitanOperationStatus commit = this.titanDao.commit();
+        assertThat(commit).isEqualTo(TitanOperationStatus.OK);
+    }
+}
\ No newline at end of file
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTemplateOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTemplateOperationTest.java
index a1a257b893..71d54bca73 100644
--- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTemplateOperationTest.java
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTemplateOperationTest.java
@@ -25,7 +25,6 @@ import org.openecomp.sdc.be.model.RelationshipImpl;
 import org.openecomp.sdc.be.model.RelationshipInfo;
 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
-
 import com.google.common.collect.Lists;
 
 import fj.data.Either;
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/PolicyOperationIntegrationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/PolicyOperationIntegrationTest.java
new file mode 100644
index 0000000000..d4188744d8
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/PolicyOperationIntegrationTest.java
@@ -0,0 +1,133 @@
+package org.openecomp.sdc.be.model.jsontitan.operations;
+
+import fj.data.Either;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.openecomp.sdc.be.dao.config.TitanSpringConfig;
+import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
+import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
+import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
+import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
+import org.openecomp.sdc.be.datatypes.elements.PolicyDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
+import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
+import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.ComponentParametersView;
+import org.openecomp.sdc.be.model.ModelTestBase;
+import org.openecomp.sdc.be.model.PolicyDefinition;
+import org.openecomp.sdc.be.model.config.ModelOperationsSpringConfig;
+import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate;
+import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import javax.annotation.Resource;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import static org.apache.commons.collections.ListUtils.union;
+import static org.assertj.core.api.Assertions.assertThat;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = {TitanSpringConfig.class, ModelOperationsSpringConfig.class})
+public class PolicyOperationIntegrationTest extends ModelTestBase {
+
+    private static final String CONTAINER_ID = "container";
+    public static final String POLICY_ID = "policy";
+    @Resource
+    private TopologyTemplateOperation topologyTemplateOperation;
+    @Resource
+    private TitanDao titanDao;
+    @Resource
+    private PolicyOperation policyOperation;
+    private PropertyDataDefinition prop1, prop2;
+    private PolicyDefinition policy;
+
+    @BeforeClass
+    public static void setupBeforeClass() {
+
+        ModelTestBase.init();
+    }
+
+    @Before
+    public void setUp() throws Exception {
+        prop1 = new PropertyDataDefinition();
+        prop1.setUniqueId("prop1");
+        prop1.setName("prop1");
+        prop1.setValue("prop1");
+
+        prop2 = new PropertyDataDefinition();
+        prop2.setUniqueId("prop2");
+        prop2.setName("prop2");
+        prop2.setValue("prop2");
+
+        policy = new PolicyDefinition();
+        policy.setUniqueId(POLICY_ID);
+
+        policy.setProperties(Arrays.asList(prop1, prop2));
+
+        GraphVertex resource = new GraphVertex(VertexTypeEnum.TOPOLOGY_TEMPLATE);
+        resource.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, CONTAINER_ID);
+        titanDao.createVertex(resource);
+        GraphVertex loadedResource = titanDao.getVertexById(CONTAINER_ID).left().value();
+        topologyTemplateOperation.addToscaDataToToscaElement(loadedResource, EdgeLabelEnum.POLICIES, VertexTypeEnum.POLICIES, policy, JsonPresentationFields.UNIQUE_ID);
+        titanDao.commit();
+    }
+
+    @After
+    public void tearDown() {
+        titanDao.rollback();
+    }
+
+    @Test
+    public void testUpdatePolicyProperties_singleProperty() {
+        PropertyDataDefinition prop1Copy = new PropertyDataDefinition(prop1);
+        prop1Copy.setValue("prop1NewValue");
+        testUpdatePolicyProperties(Collections.singletonList(prop1Copy), Collections.singletonList(prop2));
+    }
+
+    @Test
+    public void testUpdatePolicyProperties_multipleProperties() {
+        PropertyDataDefinition prop1Copy = new PropertyDataDefinition(prop1);
+        prop1Copy.setValue("prop1NewValue");
+
+        PropertyDataDefinition prop2Copy = new PropertyDataDefinition(prop2);
+        prop2Copy.setValue("prop2NewValue");
+
+        testUpdatePolicyProperties(Arrays.asList(prop1Copy, prop2Copy), Collections.emptyList());
+    }
+
+    private void testUpdatePolicyProperties(List<PropertyDataDefinition> updatedProperties, List<PropertyDataDefinition> nonUpdatedPropeties) {
+        Component cmpt = new org.openecomp.sdc.be.model.Resource();
+        cmpt.setUniqueId(CONTAINER_ID);
+        cmpt.setPolicies(Collections.singletonMap(POLICY_ID, policy));
+        StorageOperationStatus storageOperationStatus = policyOperation.updatePolicyProperties(cmpt, POLICY_ID, updatedProperties);
+        assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.OK);
+
+        ComponentParametersView componentParametersView = new ComponentParametersView();
+        componentParametersView.disableAll();
+        componentParametersView.setIgnorePolicies(false);
+        Either<ToscaElement, StorageOperationStatus> loadedCmptEither = topologyTemplateOperation.getToscaElement(CONTAINER_ID, componentParametersView);
+
+        assertThat(loadedCmptEither.isLeft());
+        ToscaElement loadedCmpt = loadedCmptEither.left().value();
+        assertThat(loadedCmpt).isInstanceOf(TopologyTemplate.class);
+        @SuppressWarnings("unchecked") List<PropertyDataDefinition> allProperties = union(updatedProperties, nonUpdatedPropeties);
+        verifyPolicyPropertiesValuesUpdated((TopologyTemplate) loadedCmpt, allProperties);
+    }
+
+    private void verifyPolicyPropertiesValuesUpdated(TopologyTemplate toscaElement, List<PropertyDataDefinition> expectedUpdatedProperties) {
+        Map<String, PolicyDataDefinition> policies = toscaElement.getPolicies();
+        PolicyDataDefinition policy = policies.get(POLICY_ID);
+        List<PropertyDataDefinition> policyProperties = policy.getProperties();
+        assertThat(policyProperties).usingElementComparatorOnFields("value")
+                                    .containsAll(expectedUpdatedProperties);
+    }
+}
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/PolicyOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/PolicyOperationTest.java
new file mode 100644
index 0000000000..136f95b987
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/PolicyOperationTest.java
@@ -0,0 +1,93 @@
+package org.openecomp.sdc.be.model.jsontitan.operations;
+
+import fj.data.Either;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
+import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
+import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
+import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
+import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.PolicyDefinition;
+import org.openecomp.sdc.be.model.Resource;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class PolicyOperationTest {
+
+    private static final String CONTAINER_ID = "containerId";
+    private static final String POLICY_ID = "policyId";
+    @InjectMocks
+    private PolicyOperation testInstance;
+    @Mock
+    private TitanDao titanDao;
+    @Mock
+    private TopologyTemplateOperation topologyTemplateOperation;
+    @Captor
+    private ArgumentCaptor<PolicyDefinition> policyDefCaptor;
+    private Component component;
+    private PolicyDefinition policyDefinition;
+    private PropertyDataDefinition prop1, prop2;
+
+    @Before
+    public void setUp() throws Exception {
+        component = new Resource();
+        component.setUniqueId(CONTAINER_ID);
+        policyDefinition = new PolicyDefinition();
+        policyDefinition.setUniqueId(POLICY_ID);
+        prop1 = new PropertyDataDefinition();
+        prop1.setName("prop1");
+        prop1.setValue("prop1");
+
+        prop2 = new PropertyDataDefinition();
+        prop2.setName("prop2");
+        prop2.setValue("prop2");
+        policyDefinition.setProperties(Arrays.asList(prop1, prop2));
+        component.setPolicies(Collections.singletonMap(POLICY_ID, policyDefinition));
+    }
+
+    @Test
+    public void updatePolicyProperties_failedToFetchContainer() {
+        when(titanDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND));
+        StorageOperationStatus storageOperationStatus = testInstance.updatePolicyProperties(component, POLICY_ID, Collections.emptyList());
+        assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.NOT_FOUND);
+        verifyZeroInteractions(topologyTemplateOperation);
+    }
+
+    @Test
+    public void updatePolicyProperties_updateFailed() {
+        GraphVertex cmptVertex = new GraphVertex();
+        when(titanDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(cmptVertex));
+        when(topologyTemplateOperation.updatePolicyOfToscaElement(cmptVertex, policyDefinition)).thenReturn(StorageOperationStatus.GENERAL_ERROR);
+        StorageOperationStatus storageOperationStatus = testInstance.updatePolicyProperties(component, POLICY_ID, Collections.emptyList());
+        assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.GENERAL_ERROR);
+    }
+
+    @Test
+    public void updatePolicyProperties() {
+        GraphVertex cmptVertex = new GraphVertex();
+        when(titanDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(cmptVertex));
+        when(topologyTemplateOperation.updatePolicyOfToscaElement(eq(cmptVertex), policyDefCaptor.capture())).thenReturn(StorageOperationStatus.OK);
+        PropertyDataDefinition prop1Copy = new PropertyDataDefinition(prop1);
+        prop1Copy.setValue("prop1Copy");
+        StorageOperationStatus storageOperationStatus = testInstance.updatePolicyProperties(component, POLICY_ID, Collections.singletonList(prop1Copy));
+        assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.OK);
+        assertThat(policyDefCaptor.getValue().getProperties()).usingElementComparatorOnFields("value")
+                .containsExactlyInAnyOrder(prop1Copy, prop2);
+    }
+}
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationCapabilityIntegrationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationCapabilityIntegrationTest.java
new file mode 100644
index 0000000000..103b27d3e6
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationCapabilityIntegrationTest.java
@@ -0,0 +1,199 @@
+package org.openecomp.sdc.be.model.jsontitan.operations;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.openecomp.sdc.be.dao.config.TitanSpringConfig;
+import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
+import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
+import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
+import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
+import org.openecomp.sdc.be.datatypes.elements.MapCapabiltyProperty;
+import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition;
+import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.ComponentParametersView;
+import org.openecomp.sdc.be.model.ModelTestBase;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.config.ModelOperationsSpringConfig;
+import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import javax.annotation.Resource;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = {TitanSpringConfig.class, ModelOperationsSpringConfig.class})
+public class TopologyTemplateOperationCapabilityIntegrationTest extends ModelTestBase {
+
+    private static final String CONTAINER_ID = "id";
+    private Map<String, MapCapabiltyProperty> capabilitiesPropsMap;
+    private List<CapabilityPropertyDataObject> capabilitiesProperties;
+
+    @Resource
+    private TopologyTemplateOperation topologyTemplateOperation;
+
+    @Resource
+    private TitanDao titanDao;
+    private CapabilityPropertyDataObject capabilityProperty1;
+    private CapabilityPropertyDataObject capabilityProperty2;
+    private CapabilityPropertyDataObject capabilityProperty3;
+
+    @BeforeClass
+    public static void setupBeforeClass() {
+
+        ModelTestBase.init();
+    }
+
+    @Before
+    public void setUp() throws Exception {
+
+        capabilitiesPropsMap = new HashMap<>();
+        capabilityProperty1 = new CapabilityPropertyDataObject("instance1", "capability1", "prop1", "val1");
+        capabilityProperty2 = new CapabilityPropertyDataObject("instance1", "capability2", "prop2", "val2");
+        capabilityProperty3 = new CapabilityPropertyDataObject("instance2", "capability3", "prop3", "val3");
+        capabilitiesProperties = Arrays.asList(capabilityProperty1, capabilityProperty2, capabilityProperty3);
+
+
+        //capablities props == Map<instance id, Map<capability id, Map<prop id, property>>>
+        capabilitiesProperties.forEach(capabilitiesProperty -> {
+            capabilitiesPropsMap.computeIfAbsent(capabilitiesProperty.getInstanceId(), k -> new MapCapabiltyProperty(new HashMap<>()))
+                             .getMapToscaDataDefinition().computeIfAbsent(capabilitiesProperty.getCapabilityId(), k -> new MapPropertiesDataDefinition(new HashMap<>()))
+                             .getMapToscaDataDefinition().computeIfAbsent(capabilitiesProperty.getPropName(), k -> new PropertyDefinition(createPropWithValue(capabilitiesProperty.getPropValue())));
+        });
+
+        GraphVertex resource = new GraphVertex(VertexTypeEnum.TOPOLOGY_TEMPLATE);
+        resource.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, CONTAINER_ID);
+        titanDao.createVertex(resource);
+        GraphVertex loadedResource = titanDao.getVertexById(CONTAINER_ID).left().value();
+        topologyTemplateOperation.assosiateElementToData(loadedResource, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, capabilitiesPropsMap).left().value();
+        titanDao.commit();
+
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        titanDao.rollback();
+    }
+
+    @Test
+    public void overrideCalculatedCapabilityProperties() {
+        Map<String, MapCapabiltyProperty> loadedCapPropsMap = fetchCapabilitiesProps(CONTAINER_ID);
+        compareCapabilitiesProperties(capabilitiesProperties, loadedCapPropsMap);
+        capabilityProperty1.setPropValue("newVal1");
+        capabilityProperty3.setPropValue("newVal3");
+        setPropertyValue(capabilitiesPropsMap, capabilityProperty1);
+        setPropertyValue(capabilitiesPropsMap, capabilityProperty3);
+        StorageOperationStatus storageOperationStatus = topologyTemplateOperation.overrideToscaDataOfToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, capabilitiesPropsMap);
+        assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.OK);
+        Map<String, MapCapabiltyProperty> updatedCapPropsMap = fetchCapabilitiesProps(CONTAINER_ID);
+        compareCapabilitiesProperties(capabilitiesProperties, updatedCapPropsMap);
+    }
+
+    @Test
+    public void updateToscaDataDeepElementsBlockToToscaElement() {
+        assertCapabilityPropValue(capabilityProperty1, "val1");
+        assertCapabilityPropValue(capabilityProperty2, "val2");
+        assertCapabilityPropValue(capabilityProperty3, "val3");
+
+        MapCapabiltyProperty instance1Props = capabilitiesPropsMap.get("instance1");
+        capabilityProperty1.setPropValue("newVal1");
+        setPropertyValue(capabilitiesPropsMap, capabilityProperty1);
+
+        capabilityProperty3.setPropValue("newVal3");
+        setPropertyValue(capabilitiesPropsMap, capabilityProperty3);
+
+        Component component = new org.openecomp.sdc.be.model.Resource();
+        component.setUniqueId(CONTAINER_ID);
+        StorageOperationStatus updateStatus = topologyTemplateOperation.updateToscaDataDeepElementsBlockToToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, instance1Props, "instance1");
+
+        assertThat(updateStatus).isEqualTo(StorageOperationStatus.OK);
+        assertCapabilityPropValue(capabilityProperty1, "newVal1");
+        assertCapabilityPropValue(capabilityProperty2, "val2");
+        assertCapabilityPropValue(capabilityProperty3, "val3");//only instance1 props should be updated
+    }
+
+    private Map<String, MapCapabiltyProperty> fetchCapabilitiesProps(String containerId) {
+        ComponentParametersView capabilityPropsFilter = new ComponentParametersView(true);
+        capabilityPropsFilter.setIgnoreCapabiltyProperties(false);
+        return ((TopologyTemplate) topologyTemplateOperation.getToscaElement(containerId, capabilityPropsFilter).left().value()).getCalculatedCapabilitiesProperties();
+    }
+
+    private void compareCapabilitiesProperties(List<CapabilityPropertyDataObject> expected, Map<String, MapCapabiltyProperty> actual) {
+        expected.forEach(expectedCapabilityProp -> {
+            assertThat(getPropertyValue(actual, expectedCapabilityProp.instanceId, expectedCapabilityProp.capabilityId, expectedCapabilityProp.propName))
+                    .isEqualTo(expectedCapabilityProp.propValue);
+        });
+    }
+
+    private String getPropertyValue(Map<String, MapCapabiltyProperty> capabilityPropertyMap, String instance, String capability, String prop) {
+        return capabilityPropertyMap.get(instance).getMapToscaDataDefinition().get(capability).getMapToscaDataDefinition().get(prop).getValue();
+    }
+
+    private void setPropertyValue(Map<String, MapCapabiltyProperty> capabilityPropertyMap, CapabilityPropertyDataObject capabilityProperty) {
+        setPropertyValue(capabilityPropertyMap.get(capabilityProperty.getInstanceId()), capabilityProperty);
+
+    }
+
+    private void setPropertyValue(MapCapabiltyProperty capabilitiesInstanceProperties, CapabilityPropertyDataObject capabilityProperty) {
+        capabilitiesInstanceProperties.getMapToscaDataDefinition().get(capabilityProperty.getCapabilityId())
+                                      .getMapToscaDataDefinition().get(capabilityProperty.getPropName())
+                                      .setValue(capabilityProperty.getPropValue());
+    }
+
+    private void assertCapabilityPropValue(CapabilityPropertyDataObject prop, String expectedValue) {
+        Map<String, MapCapabiltyProperty> loadedCapPropsMap = fetchCapabilitiesProps(CONTAINER_ID);
+        String propertyValue = getPropertyValue(loadedCapPropsMap, prop.getInstanceId(), prop.getCapabilityId(), prop.getPropName());
+        assertThat(propertyValue).isEqualTo(expectedValue);
+    }
+
+
+    private PropertyDefinition createPropWithValue(String val) {
+        PropertyDefinition propertyDefinition = new PropertyDefinition();
+        propertyDefinition.setValue(val);
+        return propertyDefinition;
+    }
+
+    private static class CapabilityPropertyDataObject {
+        private String instanceId;
+        private String capabilityId;
+        private String propName;
+        private String propValue;
+
+        CapabilityPropertyDataObject(String instanceId, String capabilityId, String propName, String propValue) {
+            this.instanceId = instanceId;
+            this.capabilityId = capabilityId;
+            this.propName = propName;
+            this.propValue = propValue;
+        }
+
+        String getInstanceId() {
+            return instanceId;
+        }
+
+        String getCapabilityId() {
+            return capabilityId;
+        }
+
+        String getPropName() {
+            return propName;
+        }
+
+        String getPropValue() {
+            return propValue;
+        }
+
+        void setPropValue(String propValue) {
+            this.propValue = propValue;
+        }
+    }
+}
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationIntegrationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationIntegrationTest.java
new file mode 100644
index 0000000000..d104cd3d42
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationIntegrationTest.java
@@ -0,0 +1,199 @@
+package org.openecomp.sdc.be.model.jsontitan.operations;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.openecomp.sdc.be.dao.config.TitanSpringConfig;
+import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
+import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
+import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
+import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
+import org.openecomp.sdc.be.datatypes.elements.MapCapabiltyProperty;
+import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition;
+import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.ComponentParametersView;
+import org.openecomp.sdc.be.model.ModelTestBase;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.config.ModelOperationsSpringConfig;
+import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import javax.annotation.Resource;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = {TitanSpringConfig.class, ModelOperationsSpringConfig.class})
+public class TopologyTemplateOperationIntegrationTest extends ModelTestBase {
+
+    private static final String CONTAINER_ID = "id";
+    private Map<String, MapCapabiltyProperty> capabilitiesPropsMap;
+    private List<CapabilityPropertyDataObject> capabilitiesProperties;
+
+    @Resource
+    private TopologyTemplateOperation topologyTemplateOperation;
+
+    @Resource
+    private TitanDao titanDao;
+    private CapabilityPropertyDataObject capabilityProperty1;
+    private CapabilityPropertyDataObject capabilityProperty2;
+    private CapabilityPropertyDataObject capabilityProperty3;
+
+    @BeforeClass
+    public static void setupBeforeClass() {
+
+        ModelTestBase.init();
+    }
+
+    @Before
+    public void setUp() throws Exception {
+
+        capabilitiesPropsMap = new HashMap<>();
+        capabilityProperty1 = new CapabilityPropertyDataObject("instance1", "capability1", "prop1", "val1");
+        capabilityProperty2 = new CapabilityPropertyDataObject("instance1", "capability2", "prop2", "val2");
+        capabilityProperty3 = new CapabilityPropertyDataObject("instance2", "capability3", "prop3", "val3");
+        capabilitiesProperties = Arrays.asList(capabilityProperty1, capabilityProperty2, capabilityProperty3);
+
+
+        //capablities props == Map<instance id, Map<capability id, Map<prop id, property>>>
+        capabilitiesProperties.forEach(capabilitiesProperty -> {
+            capabilitiesPropsMap.computeIfAbsent(capabilitiesProperty.getInstanceId(), k -> new MapCapabiltyProperty(new HashMap<>()))
+                             .getMapToscaDataDefinition().computeIfAbsent(capabilitiesProperty.getCapabilityId(), k -> new MapPropertiesDataDefinition(new HashMap<>()))
+                             .getMapToscaDataDefinition().computeIfAbsent(capabilitiesProperty.getPropName(), k -> new PropertyDefinition(createPropWithValue(capabilitiesProperty.getPropValue())));
+        });
+
+        GraphVertex resource = new GraphVertex(VertexTypeEnum.TOPOLOGY_TEMPLATE);
+        resource.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, CONTAINER_ID);
+        titanDao.createVertex(resource);
+        GraphVertex loadedResource = titanDao.getVertexById(CONTAINER_ID).left().value();
+        topologyTemplateOperation.assosiateElementToData(loadedResource, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, capabilitiesPropsMap).left().value();
+        titanDao.commit();
+
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        titanDao.rollback();
+    }
+
+    @Test
+    public void overrideCalculatedCapabilityProperties() {
+        Map<String, MapCapabiltyProperty> loadedCapPropsMap = fetchCapabilitiesProps(CONTAINER_ID);
+        compareCapabilitiesProperties(capabilitiesProperties, loadedCapPropsMap);
+        capabilityProperty1.setPropValue("newVal1");
+        capabilityProperty3.setPropValue("newVal3");
+        setPropertyValue(capabilitiesPropsMap, capabilityProperty1);
+        setPropertyValue(capabilitiesPropsMap, capabilityProperty3);
+        StorageOperationStatus storageOperationStatus = topologyTemplateOperation.overrideToscaDataOfToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, capabilitiesPropsMap);
+        assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.OK);
+        Map<String, MapCapabiltyProperty> updatedCapPropsMap = fetchCapabilitiesProps(CONTAINER_ID);
+        compareCapabilitiesProperties(capabilitiesProperties, updatedCapPropsMap);
+    }
+
+    @Test
+    public void updateToscaDataDeepElementsBlockToToscaElement() {
+        assertCapabilityPropValue(capabilityProperty1, "val1");
+        assertCapabilityPropValue(capabilityProperty2, "val2");
+        assertCapabilityPropValue(capabilityProperty3, "val3");
+
+        MapCapabiltyProperty instance1Props = capabilitiesPropsMap.get("instance1");
+        capabilityProperty1.setPropValue("newVal1");
+        setPropertyValue(capabilitiesPropsMap, capabilityProperty1);
+
+        capabilityProperty3.setPropValue("newVal3");
+        setPropertyValue(capabilitiesPropsMap, capabilityProperty3);
+
+        Component component = new org.openecomp.sdc.be.model.Resource();
+        component.setUniqueId(CONTAINER_ID);
+        StorageOperationStatus updateStatus = topologyTemplateOperation.updateToscaDataDeepElementsBlockToToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, instance1Props, "instance1");
+
+        assertThat(updateStatus).isEqualTo(StorageOperationStatus.OK);
+        assertCapabilityPropValue(capabilityProperty1, "newVal1");
+        assertCapabilityPropValue(capabilityProperty2, "val2");
+        assertCapabilityPropValue(capabilityProperty3, "val3");//only instance1 props should be updated
+    }
+
+    private Map<String, MapCapabiltyProperty> fetchCapabilitiesProps(String containerId) {
+        ComponentParametersView capabilityPropsFilter = new ComponentParametersView(true);
+        capabilityPropsFilter.setIgnoreCapabiltyProperties(false);
+        return ((TopologyTemplate) topologyTemplateOperation.getToscaElement(containerId, capabilityPropsFilter).left().value()).getCalculatedCapabilitiesProperties();
+    }
+
+    private void compareCapabilitiesProperties(List<CapabilityPropertyDataObject> expected, Map<String, MapCapabiltyProperty> actual) {
+        expected.forEach(expectedCapabilityProp -> {
+            assertThat(getPropertyValue(actual, expectedCapabilityProp.instanceId, expectedCapabilityProp.capabilityId, expectedCapabilityProp.propName))
+                    .isEqualTo(expectedCapabilityProp.propValue);
+        });
+    }
+
+    private String getPropertyValue(Map<String, MapCapabiltyProperty> capabilityPropertyMap, String instance, String capability, String prop) {
+        return capabilityPropertyMap.get(instance).getMapToscaDataDefinition().get(capability).getMapToscaDataDefinition().get(prop).getValue();
+    }
+
+    private void setPropertyValue(Map<String, MapCapabiltyProperty> capabilityPropertyMap, CapabilityPropertyDataObject capabilityProperty) {
+        setPropertyValue(capabilityPropertyMap.get(capabilityProperty.getInstanceId()), capabilityProperty);
+
+    }
+
+    private void setPropertyValue(MapCapabiltyProperty capabilitiesInstanceProperties, CapabilityPropertyDataObject capabilityProperty) {
+        capabilitiesInstanceProperties.getMapToscaDataDefinition().get(capabilityProperty.getCapabilityId())
+                                      .getMapToscaDataDefinition().get(capabilityProperty.getPropName())
+                                      .setValue(capabilityProperty.getPropValue());
+    }
+
+    private void assertCapabilityPropValue(CapabilityPropertyDataObject prop, String expectedValue) {
+        Map<String, MapCapabiltyProperty> loadedCapPropsMap = fetchCapabilitiesProps(CONTAINER_ID);
+        String propertyValue = getPropertyValue(loadedCapPropsMap, prop.getInstanceId(), prop.getCapabilityId(), prop.getPropName());
+        assertThat(propertyValue).isEqualTo(expectedValue);
+    }
+
+
+    private PropertyDefinition createPropWithValue(String val) {
+        PropertyDefinition propertyDefinition = new PropertyDefinition();
+        propertyDefinition.setValue(val);
+        return propertyDefinition;
+    }
+
+    private static class CapabilityPropertyDataObject {
+        private String instanceId;
+        private String capabilityId;
+        private String propName;
+        private String propValue;
+
+        CapabilityPropertyDataObject(String instanceId, String capabilityId, String propName, String propValue) {
+            this.instanceId = instanceId;
+            this.capabilityId = capabilityId;
+            this.propName = propName;
+            this.propValue = propValue;
+        }
+
+        String getInstanceId() {
+            return instanceId;
+        }
+
+        String getCapabilityId() {
+            return capabilityId;
+        }
+
+        String getPropName() {
+            return propName;
+        }
+
+        String getPropValue() {
+            return propValue;
+        }
+
+        void setPropValue(String propValue) {
+            this.propValue = propValue;
+        }
+    }
+}
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationTest.java
new file mode 100644
index 0000000000..7756a08cc1
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationTest.java
@@ -0,0 +1,125 @@
+package org.openecomp.sdc.be.model.jsontitan.operations;
+
+import fj.data.Either;
+
+import org.apache.tinkerpop.gremlin.structure.Direction;
+import org.apache.tinkerpop.gremlin.structure.Edge;
+import org.apache.tinkerpop.gremlin.structure.Property;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
+import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
+import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
+import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
+import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
+import org.openecomp.sdc.be.datatypes.elements.MapCapabiltyProperty;
+import org.openecomp.sdc.be.datatypes.elements.MapDataDefinition;
+import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
+import org.openecomp.sdc.be.model.PolicyDefinition;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
+import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
+
+import com.thinkaurelius.titan.core.PropertyKey;
+import com.thinkaurelius.titan.core.TitanEdge;
+import com.thinkaurelius.titan.core.TitanTransaction;
+import com.thinkaurelius.titan.core.TitanVertex;
+import com.thinkaurelius.titan.core.TitanVertexProperty;
+import com.thinkaurelius.titan.core.TitanVertexQuery;
+import com.thinkaurelius.titan.core.VertexLabel;
+import com.thinkaurelius.titan.diskstorage.EntryMetaData.Map;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+//error scenarios
+public class TopologyTemplateOperationTest {
+
+    private static final String CONTAINER_ID = "containerId";
+    @InjectMocks
+    private TopologyTemplateOperation topologyTemplateOperation;
+    @Mock
+    private TitanDao titanDao;
+
+    @Test
+    public void overrideToscaDataOfToscaElement_failedToFetchContainerVertex() {
+        when(titanDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.right(TitanOperationStatus.INVALID_ID));
+        StorageOperationStatus storageOperationStatus = topologyTemplateOperation.overrideToscaDataOfToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, Collections.emptyMap());
+        assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.INVALID_ID);
+    }
+
+    @Test
+    public void overrideToscaDataOfToscaElement_failedToFetchDataVertex() {
+        GraphVertex containerVertex = new GraphVertex();
+        when(titanDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(containerVertex));
+        when(titanDao.getChildVertex(containerVertex, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, JsonParseFlagEnum.ParseJson)).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND));
+        StorageOperationStatus storageOperationStatus = topologyTemplateOperation.overrideToscaDataOfToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, Collections.emptyMap());
+        assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.NOT_FOUND);
+    }
+
+    @Test
+    public void updateToscaDataDeepElements_failedToFetchContainerVertex() {
+        when(titanDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.right(TitanOperationStatus.INVALID_ID));
+        StorageOperationStatus storageOperationStatus = topologyTemplateOperation.updateToscaDataDeepElementsBlockToToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, new MapCapabiltyProperty(), "");
+        assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.INVALID_ID);
+    }
+
+    @Test
+    public void updateToscaDataDeepElements_failedToFetchDataVertex() {
+        GraphVertex containerVertex = new GraphVertex();
+        when(titanDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(containerVertex));
+        when(titanDao.getChildVertex(containerVertex, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, JsonParseFlagEnum.ParseJson)).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND));
+        StorageOperationStatus storageOperationStatus = topologyTemplateOperation.updateToscaDataDeepElementsBlockToToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, new MapCapabiltyProperty(), "");
+        assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.NOT_FOUND);
+    }
+    
+	@Test
+    public void addPolicyToToscaElementSuccessTest(){
+    	TitanOperationStatus status = TitanOperationStatus.OK;
+    	StorageOperationStatus result = addPolicyToToscaElementWithStatus(status);
+    	assertThat(result).isEqualTo(StorageOperationStatus.OK);
+    }
+    
+	@Test
+    public void addPolicyToToscaElementFailureTest(){
+    	TitanOperationStatus status = TitanOperationStatus.ALREADY_EXIST;
+    	StorageOperationStatus result = addPolicyToToscaElementWithStatus(status);
+    	assertThat(result).isEqualTo(StorageOperationStatus.ENTITY_ALREADY_EXISTS);
+    }
+
+	@SuppressWarnings("unchecked")
+	private StorageOperationStatus addPolicyToToscaElementWithStatus(TitanOperationStatus status) {
+		GraphVertex componentV = new GraphVertex();
+    	componentV.setVertex(Mockito.mock(TitanVertex.class));
+    	GraphVertex dataV = new GraphVertex();
+    	dataV.setVertex(Mockito.mock(TitanVertex.class));
+    	String componentName = "componentName";
+    	String componentId = UniqueIdBuilder.buildResourceUniqueId();
+    	String policyTypeName = "org.openecomp.policies.placement.valet.Affinity";
+    	componentV.setJsonMetadataField(JsonPresentationFields.NAME, componentName);
+    	componentV.setUniqueId(componentId);
+    	PolicyDefinition policy = new PolicyDefinition();
+    	policy.setPolicyTypeName(policyTypeName);
+    	int counter = 0;
+    	Either<GraphVertex, TitanOperationStatus> toscaDataVertexRes = Either.right(TitanOperationStatus.NOT_FOUND);
+    	when(titanDao.getChildVertex(eq(componentV), eq(EdgeLabelEnum.POLICIES), eq(JsonParseFlagEnum.ParseJson))).thenReturn(toscaDataVertexRes);
+		Either<GraphVertex, TitanOperationStatus> createVertex = Either.left(dataV);
+		when(titanDao.createVertex(any(GraphVertex.class))).thenReturn(createVertex);
+		when(titanDao.createEdge(any(TitanVertex.class), any(TitanVertex.class), any(EdgeLabelEnum.class), any(HashMap.class))).thenReturn(status);
+    	return topologyTemplateOperation.addPolicyToToscaElement(componentV, policy, counter);
+	}
+    
+}
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationTest.java
index 806c22a8fb..d9148a18e1 100644
--- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationTest.java
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationTest.java
@@ -22,6 +22,7 @@ import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
 import org.openecomp.sdc.be.model.LifecycleStateEnum;
 import org.openecomp.sdc.be.model.ModelTestBase;
+import org.openecomp.sdc.be.model.catalog.CatalogComponent;
 import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement;
 import org.openecomp.sdc.be.model.jsontitan.utils.GraphTestUtils;
 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
@@ -81,6 +82,9 @@ public class ToscaElementOperationTest extends ModelTestBase{
         }, null);
         assertEquals(highestResources.stream().count(), highestResourcesExpectedCount);
     }
+    
+   
+
 
     @Test
     public void testGetAllResourcesCertifiedNoFilter() {
@@ -268,6 +272,8 @@ public class ToscaElementOperationTest extends ModelTestBase{
     }
 
     private void initGraphForTest() {
+		GraphTestUtils.createRootCatalogVertex(titanDao);
+
         Map<GraphPropertyEnum, Object> highstVerticesProps = new HashMap<GraphPropertyEnum, Object>() {
             {
                 put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacadePoliciesTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacadePoliciesTest.java
new file mode 100644
index 0000000000..6a4a117360
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacadePoliciesTest.java
@@ -0,0 +1,144 @@
+package org.openecomp.sdc.be.model.jsontitan.operations;
+
+import fj.data.Either;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.openecomp.sdc.be.dao.config.TitanSpringConfig;
+import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
+import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
+import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
+import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
+import org.openecomp.sdc.be.datatypes.elements.PolicyTargetType;
+import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
+import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
+import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.ComponentParametersView;
+import org.openecomp.sdc.be.model.ModelTestBase;
+import org.openecomp.sdc.be.model.PolicyDefinition;
+import org.openecomp.sdc.be.model.config.ModelOperationsSpringConfig;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.singletonList;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertTrue;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = {TitanSpringConfig.class, ModelOperationsSpringConfig.class})
+public class ToscaOperationFacadePoliciesTest extends ModelTestBase {
+
+    private static final String CONTAINER_ID = "containerId";
+    private static final String CONTAINER_NAME = "containerName";
+    @Autowired
+    private ToscaOperationFacade toscaOperationFacade;
+    @Autowired
+    private TitanDao titanDao;
+
+    private PolicyDefinition policy1, policy2;
+
+    @BeforeClass
+    public static void setupBeforeClass() {
+        ModelTestBase.init();
+    }
+
+    @Before
+    public void setUp() throws Exception {
+        policy1 = createPolicyDefinition("type1");
+        policy2 = createPolicyDefinition("type2");
+        createContainerVertexInDB();
+        createPoliciesOnGraph(policy1, policy2);
+    }
+
+    private void createPoliciesOnGraph(PolicyDefinition ... policies) {
+        for (int i = 0; i < policies.length; i++) {
+            PolicyDefinition policy = policies[i];
+            Either<PolicyDefinition, StorageOperationStatus> createdPolicy = toscaOperationFacade.associatePolicyToComponent(CONTAINER_ID, policy, i);
+            assertTrue(createdPolicy.isLeft());
+        }
+    }
+
+    @After
+    public void tearDown() {
+        titanDao.rollback();
+    }
+
+    @Test
+    public void updatePoliciesTargetsOfComponent_updateSinglePolicy() {
+        List<String> updatedTargetIds = asList("instance1new", "instance2");
+        PolicyDefinition originalPolicy2 = clonePolicyWithTargets(policy2);
+        updatePolicyTypeTargetsIds(policy1, PolicyTargetType.COMPONENT_INSTANCES, updatedTargetIds);
+        updatePolicyTypeTargetsIds(policy2, PolicyTargetType.COMPONENT_INSTANCES, updatedTargetIds);
+
+        StorageOperationStatus storageOperationStatus = toscaOperationFacade.updatePoliciesOfComponent(CONTAINER_ID, singletonList(policy1));
+        assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.OK);
+        Component updatedComponent = fetchComponentFromDB();
+        verifyPolicyTargets(updatedComponent.getPolicyById(policy1.getUniqueId()), policy1);
+        verifyPolicyTargets(updatedComponent.getPolicyById(policy2.getUniqueId()), originalPolicy2);
+    }
+
+    @Test
+    public void updatePoliciesTargetsOfComponent_updateMultiplePolicies() {
+        List<String> updatedTargetIds = asList("instance1new", "instance2");
+        updatePolicyTypeTargetsIds(policy1, PolicyTargetType.COMPONENT_INSTANCES, updatedTargetIds);
+        updatePolicyTypeTargetsIds(policy2, PolicyTargetType.COMPONENT_INSTANCES, updatedTargetIds);
+        StorageOperationStatus storageOperationStatus = toscaOperationFacade.updatePoliciesOfComponent(CONTAINER_ID, asList(policy1, policy2));
+        assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.OK);
+        Component updatedComponent = fetchComponentFromDB();
+        verifyPolicyTargets(updatedComponent.getPolicyById(policy1.getUniqueId()), policy1);
+        verifyPolicyTargets(updatedComponent.getPolicyById(policy2.getUniqueId()), policy2);
+    }
+
+    private PolicyDefinition clonePolicyWithTargets(PolicyDefinition policy) {
+        PolicyDefinition originalPolicy = new PolicyDefinition(policy);
+        Map<PolicyTargetType, List<String>> clonedTargetMap = policy.getTargets().entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, entry -> new ArrayList<>(entry.getValue())));
+        originalPolicy.setTargets(clonedTargetMap);
+        return originalPolicy;
+    }
+
+    private void verifyPolicyTargets(PolicyDefinition updatedPolicy, PolicyDefinition expectedPolicy) {
+        assertThat(updatedPolicy.getTargets())
+                .isEqualTo(expectedPolicy.getTargets());
+    }
+
+    private void updatePolicyTypeTargetsIds(PolicyDefinition policy, PolicyTargetType targetType, List<String> updatedTargetIds) {
+        policy.getTargets().put(targetType, updatedTargetIds);
+    }
+
+    private Component fetchComponentFromDB() {
+        ComponentParametersView componentParametersView = new ComponentParametersView();
+        componentParametersView.disableAll();
+        componentParametersView.setIgnorePolicies(false);
+        return toscaOperationFacade.getToscaElement(CONTAINER_ID, componentParametersView).left().value();
+    }
+
+    private void createContainerVertexInDB() {
+        GraphVertex resource = new GraphVertex(VertexTypeEnum.TOPOLOGY_TEMPLATE);
+        resource.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, CONTAINER_ID);
+        resource.addMetadataProperty(GraphPropertyEnum.NAME, CONTAINER_NAME);
+        resource.setJsonMetadataField(JsonPresentationFields.NAME, CONTAINER_NAME);
+        resource.setJsonMetadataField(JsonPresentationFields.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name());
+        Either<GraphVertex, TitanOperationStatus> container = titanDao.createVertex(resource);
+        assertTrue(container.isLeft());
+    }
+
+    private PolicyDefinition createPolicyDefinition(String type) {
+        PolicyDefinition policy = new PolicyDefinition();
+        policy.setPolicyTypeName(type);
+        policy.setTargets(new HashMap<>());
+        policy.getTargets().put(PolicyTargetType.COMPONENT_INSTANCES, asList("instance1", "instance2"));
+        return policy;
+    }
+}
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacadeTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacadeTest.java
index 4a7d27812d..37d466c648 100644
--- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacadeTest.java
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacadeTest.java
@@ -1,15 +1,6 @@
 package org.openecomp.sdc.be.model.jsontitan.operations;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.when;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-import java.util.stream.IntStream;
-
+import fj.data.Either;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -29,11 +20,24 @@ import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
 import org.openecomp.sdc.be.model.Component;
 import org.openecomp.sdc.be.model.ComponentParametersView;
+import org.openecomp.sdc.be.model.PolicyDefinition;
 import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate;
 import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement;
 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
 
-import fj.data.Either;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyMap;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
 
 @RunWith(MockitoJUnitRunner.class)
 public class ToscaOperationFacadeTest {
@@ -58,16 +62,18 @@ public class ToscaOperationFacadeTest {
     @Test
     public void fetchMetaDataByResourceType() throws Exception {
         ArgumentCaptor<Map> criteriaCapture = ArgumentCaptor.forClass(Map.class);
+        ArgumentCaptor<Map> criteriaNotCapture = ArgumentCaptor.forClass(Map.class);
         ComponentParametersView dataFilter = new ComponentParametersView();
         List<GraphVertex> mockVertices = getMockVertices(2);
         Either<List<GraphVertex>, TitanOperationStatus> returnedVertices = Either.left(mockVertices);
 
-        when(titanDaoMock.getByCriteria(Mockito.eq(null), criteriaCapture.capture(), Mockito.eq(JsonParseFlagEnum.ParseMetadata))).thenReturn(returnedVertices);
+        when(titanDaoMock.getByCriteria(eq(null), criteriaCapture.capture(), criteriaNotCapture.capture(), eq(JsonParseFlagEnum.ParseMetadata))).thenReturn(returnedVertices);
         when(topologyTemplateOperationMock.getToscaElement(mockVertices.get(0), dataFilter)).thenReturn(Either.left(getResourceToscaElement("0")));
         when(topologyTemplateOperationMock.getToscaElement(mockVertices.get(1), dataFilter)).thenReturn(Either.left(getResourceToscaElement("1")));
         Either<List<Component>, StorageOperationStatus> fetchedComponents = testInstance.fetchMetaDataByResourceType(ResourceTypeEnum.VF.getValue(), dataFilter);
 
         verifyCriteriaForHighestVersionAndVfResourceType(criteriaCapture);
+        verifyCriteriaNotIsDeleted(criteriaNotCapture);
 
         assertTrue(fetchedComponents.isLeft());
         List<Component> cmpts = fetchedComponents.left().value();
@@ -83,17 +89,93 @@ public class ToscaOperationFacadeTest {
         assertEquals(criteria.get(GraphPropertyEnum.IS_HIGHEST_VERSION), true);
     }
 
+    private void verifyCriteriaNotIsDeleted(ArgumentCaptor<Map> criteriaNotCapture) {
+        Map<GraphPropertyEnum, Object> notCriteria = (Map<GraphPropertyEnum, Object>)criteriaNotCapture.getValue();
+        assertEquals(1, notCriteria.size());
+        assertEquals(notCriteria.get(GraphPropertyEnum.IS_DELETED), true);
+    }
+
     @SuppressWarnings("unchecked")
     @Test
     public void fetchMetaDataByResourceType_failedToGetData() throws Exception {
-        when(titanDaoMock.getByCriteria(Mockito.eq(null), Mockito.anyMap(), Mockito.eq(JsonParseFlagEnum.ParseMetadata))).thenReturn(Either.right(TitanOperationStatus.GENERAL_ERROR));
+        when(titanDaoMock.getByCriteria(eq(null), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseMetadata))).thenReturn(Either.right(TitanOperationStatus.GENERAL_ERROR));
         Either<List<Component>, StorageOperationStatus> fetchedComponents = testInstance.fetchMetaDataByResourceType(ResourceTypeEnum.VF.getValue(), new ComponentParametersView());
         assertTrue(fetchedComponents.isRight());
         assertEquals(StorageOperationStatus.GENERAL_ERROR, fetchedComponents.right().value());
     }
+    
+    @Test
+    public void associatePolicyToComponentSuccessTest(){
+    	Either<PolicyDefinition, StorageOperationStatus> result = associatePolicyToComponentWithStatus(StorageOperationStatus.OK);
+    	assertTrue(result.isLeft());
+    }
+
+	@Test
+    public void associatePolicyToComponentFailureTest(){
+		Either<PolicyDefinition, StorageOperationStatus> result = associatePolicyToComponentWithStatus(StorageOperationStatus.BAD_REQUEST);
+    	assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.BAD_REQUEST);
+    }
+
+    @Test
+    public void updatePolicyOfComponentSuccessTest(){
+    	Either<PolicyDefinition, StorageOperationStatus> result = updatePolicyOfComponentWithStatus(StorageOperationStatus.OK);
+    	assertTrue(result.isLeft());
+    }
+
+	@Test
+    public void updatePolicyOfComponentFailureTest(){
+		Either<PolicyDefinition, StorageOperationStatus> result = updatePolicyOfComponentWithStatus(StorageOperationStatus.NOT_FOUND);
+    	assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.NOT_FOUND);
+    }
+    
+    @Test
+    public void removePolicyFromComponentSuccessTest(){
+    	removePolicyFromComponentWithStatus(StorageOperationStatus.OK);
+    }
+    
+    @Test
+    public void removePolicyFromComponentFailureTest(){
+    	removePolicyFromComponentWithStatus(StorageOperationStatus.NOT_FOUND);
+    }
+    
+    private Either<PolicyDefinition, StorageOperationStatus> associatePolicyToComponentWithStatus(StorageOperationStatus status) {
+    	PolicyDefinition policy = new PolicyDefinition();
+    	String componentId = "componentId";
+    	int counter = 0;
+    	GraphVertex vertex;
+    	if(status == StorageOperationStatus.OK){
+    		vertex = getTopologyTemplateVertex();
+    	} else {
+    		vertex = getNodeTypeVertex();
+    	}
+    	Either<GraphVertex, TitanOperationStatus> getVertexEither = Either.left(vertex);
+    	when(titanDaoMock.getVertexById(eq(componentId), eq(JsonParseFlagEnum.ParseMetadata))).thenReturn(getVertexEither);
+    	when(topologyTemplateOperationMock.addPolicyToToscaElement(eq(vertex), any(PolicyDefinition.class), anyInt())).thenReturn(status);
+    	return testInstance.associatePolicyToComponent(componentId, policy, counter);
+    }
+    
+    private Either<PolicyDefinition, StorageOperationStatus> updatePolicyOfComponentWithStatus(StorageOperationStatus status) {
+    	PolicyDefinition policy = new PolicyDefinition();
+    	String componentId = "componentId";
+    	GraphVertex vertex = getTopologyTemplateVertex();
+    	when(titanDaoMock.getVertexById(eq(componentId), eq(JsonParseFlagEnum.NoParse))).thenReturn(Either.left(vertex));
+    	when(topologyTemplateOperationMock.updatePolicyOfToscaElement(eq(vertex), any(PolicyDefinition.class))).thenReturn(status);
+    	return testInstance.updatePolicyOfComponent(componentId, policy);
+    }
 
+	private void removePolicyFromComponentWithStatus(StorageOperationStatus status) {
+		String componentId = "componentId";
+    	String policyId = "policyId";
+    	GraphVertex vertex = getTopologyTemplateVertex();
+    	Either<GraphVertex, TitanOperationStatus> getVertexEither = Either.left(vertex);
+    	when(titanDaoMock.getVertexById(eq(componentId), eq(JsonParseFlagEnum.NoParse))).thenReturn(getVertexEither);
+    	when(topologyTemplateOperationMock.removePolicyFromToscaElement(eq(vertex), eq(policyId))).thenReturn(status);
+    	StorageOperationStatus result = testInstance.removePolicyFromComponent(componentId, policyId);
+    	assertTrue(result == status);
+	}
+    
     private List<GraphVertex> getMockVertices(int numOfVertices) {
-        return IntStream.range(0, numOfVertices).mapToObj(i -> getMockVertex()).collect(Collectors.toList());
+        return IntStream.range(0, numOfVertices).mapToObj(i -> getTopologyTemplateVertex()).collect(Collectors.toList());
     }
 
     private ToscaElement getResourceToscaElement(String id) {
@@ -104,9 +186,15 @@ public class ToscaOperationFacadeTest {
         return toscaElement;
     }
 
-    private GraphVertex getMockVertex() {
+    private GraphVertex getTopologyTemplateVertex() {
         GraphVertex graphVertex = new GraphVertex();
         graphVertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE);
         return graphVertex;
     }
+    
+    private GraphVertex getNodeTypeVertex() {
+        GraphVertex graphVertex = new GraphVertex();
+        graphVertex.setLabel(VertexTypeEnum.NODE_TYPE);
+        return graphVertex;
+    }
 }
\ No newline at end of file
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/GraphTestUtils.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/GraphTestUtils.java
index 862515c58e..72919b6136 100644
--- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/GraphTestUtils.java
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/GraphTestUtils.java
@@ -32,6 +32,7 @@ import org.apache.tinkerpop.gremlin.structure.io.IoCore;
 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
 import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
+import org.openecomp.sdc.be.dao.jsongraph.utils.IdBuilderUtils;
 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
@@ -44,6 +45,12 @@ import fj.data.Either;
 
 public final class GraphTestUtils {
 
+	public static void createRootCatalogVertex(TitanDao titanDao) {
+		GraphVertex catalogRootVertex = new GraphVertex(VertexTypeEnum.CATALOG_ROOT);
+		catalogRootVertex.setUniqueId(IdBuilderUtils.generateUniqueId());
+		titanDao.createVertex(catalogRootVertex);
+	}
+
     public static GraphVertex createResourceVertex(TitanDao titanDao, Map<GraphPropertyEnum,Object> metadataProps, ResourceTypeEnum type) {
         GraphVertex vertex = new GraphVertex();
         if (type == ResourceTypeEnum.VF) {
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/GroupTypeOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/GroupTypeOperationTest.java
new file mode 100644
index 0000000000..809134ecb6
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/GroupTypeOperationTest.java
@@ -0,0 +1,346 @@
+package org.openecomp.sdc.be.model.operations.impl;
+
+import fj.data.Either;
+import org.apache.tinkerpop.gremlin.structure.Edge;
+import org.junit.After;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
+import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
+import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
+import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
+import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
+import org.openecomp.sdc.be.model.GroupTypeDefinition;
+import org.openecomp.sdc.be.model.ModelTestBase;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.tosca.ToscaType;
+import org.openecomp.sdc.be.resources.data.CapabilityTypeData;
+import org.openecomp.sdc.be.resources.data.GroupTypeData;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import javax.annotation.Resource;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static com.google.common.collect.Sets.newHashSet;
+import static java.util.Arrays.asList;
+import static java.util.Collections.singletonList;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.*;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration("classpath:application-context-test.xml")
+public class GroupTypeOperationTest extends ModelTestBase {
+    private static final String TOSCA_GROUPS_ROOT = "tosca.groups.Root";
+
+    @Resource(name = "titan-generic-dao")
+    private TitanGenericDao titanDao;
+    
+    @Resource(name = "capability-type-operation")
+    private CapabilityTypeOperation capabilityTypeOperation;
+    
+    @Resource(name = "group-type-operation")
+    private GroupTypeOperation groupTypeOperation;
+    
+    @BeforeClass
+    public static void setupBeforeClass() {
+        ModelTestBase.init();
+    }
+
+    @After
+    public void tearDown() {
+        titanDao.rollback();
+    }
+
+    @Test
+    public void getAllGroupTypes() {
+        GroupTypeDefinition rootGroupDefinition = createRootGroupDefinition();
+        GroupTypeDefinition type1 = createGroupType("type1");
+        GroupTypeDefinition type2 = createGroupType("type2");
+        groupTypeOperation.addGroupType(rootGroupDefinition);
+        groupTypeOperation.addGroupType(type1);
+        groupTypeOperation.addGroupType(type2);
+
+        List<GroupTypeDefinition> allGroupTypesNoExclusion = groupTypeOperation.getAllGroupTypes(null);
+        assertThat(allGroupTypesNoExclusion)
+                .usingElementComparatorOnFields("type")
+                .containsExactlyInAnyOrder(rootGroupDefinition, type1, type2);
+    }
+
+    @Test
+    public void getAllGroupTypes_whenPassingExclusionList_doNotReturnExcludedTypes() {
+        GroupTypeDefinition rootGroupDefinition = createRootGroupDefinition();
+        GroupTypeDefinition type1 = createGroupType("type1");
+        GroupTypeDefinition type2 = createGroupType("type2");
+        groupTypeOperation.addGroupType(rootGroupDefinition);
+        groupTypeOperation.addGroupType(type1);
+        groupTypeOperation.addGroupType(type2);
+
+        List<GroupTypeDefinition> allGroupTypes = groupTypeOperation.getAllGroupTypes(newHashSet("type1", "type2"));
+        assertThat(allGroupTypes)
+                .usingElementComparatorOnFields("type")
+                .containsExactly(rootGroupDefinition);
+    }
+
+    @Test
+    public void groupTypeWithoutCapabilityTypeCreated() {
+        GroupTypeData rootNode = getOrCreateRootGroupTypeNode();
+        
+        GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
+        groupTypeDefinition.setDerivedFrom(TOSCA_GROUPS_ROOT);
+        groupTypeDefinition.setDescription("groups l3-networks in network collection");
+        groupTypeDefinition.setType("org.openecomp.groups.NetworkCollection");
+        groupTypeDefinition.setVersion("1.0");
+        
+        List<PropertyDefinition> properties = asList(
+                buildProperty("network_collection_type", "l3-network", "network collection type, defined with default value"),
+                buildProperty("network_collection_subtype", "sub-interface", "network collection subtype, defined with default value"),
+                buildProperty("network_collection_role", null, "network collection role"),
+                buildProperty("network_collection_description", null, "network collection description, free format text"));
+        
+        groupTypeDefinition.setProperties(properties );
+        
+        Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult =  groupTypeOperation.addGroupType(groupTypeDefinition, false);
+        assertEquals("check group type added", true, addGroupTypeResult.isLeft());
+        compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value());
+        
+        addGroupTypeResult = groupTypeOperation.getGroupTypeByTypeAndVersion("org.openecomp.groups.NetworkCollection", "1.0");
+        assertEquals("check group type added", true, addGroupTypeResult.isLeft());
+        compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value());
+        
+        Either<GroupTypeData, TitanOperationStatus> groupTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), groupTypeDefinition.getType(), GroupTypeData.class);
+        GroupTypeData groupTypeNode = extractVal(groupTypeResult);
+        
+        Either<Edge, TitanOperationStatus> edgeResult = titanDao.getEdgeByNodes(groupTypeNode, rootNode, GraphEdgeLabels.DERIVED_FROM);
+        validate(edgeResult);
+    }
+    
+    @Test
+    public void groupTypeWithCapabilityTypeAndEdgeCreated() {
+        GroupTypeData rootNode = getOrCreateRootGroupTypeNode();
+        
+        CapabilityTypeDefinition capabilityTypeDef = createCapabilityType();
+        Either<CapabilityTypeData, TitanOperationStatus> capabilityTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), capabilityTypeDef.getType(), CapabilityTypeData.class);
+        CapabilityTypeData capabilityTypeNode = extractVal(capabilityTypeResult);
+        
+        GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
+        groupTypeDefinition.setDerivedFrom(TOSCA_GROUPS_ROOT);
+        groupTypeDefinition.setDescription("groups l3-networks in network collection");
+        groupTypeDefinition.setType("org.openecomp.groups.NetworkCollection");
+        groupTypeDefinition.setCapabilityTypes(asList(capabilityTypeDef));
+        
+        List<PropertyDefinition> properties = asList(
+                buildProperty("vfc_instance_group_role", null, "role of this VFC group"),
+                buildProperty("vfc_parent_port_role", null, "common role of parent ports of VFCs in this group"),
+                buildProperty("network_collection_role", null, "network collection role assigned to this group"),
+                buildProperty("subinterface_role", null, "common role of subinterfaces of VFCs in this group, criteria the group is created"));
+
+        groupTypeDefinition.setProperties(properties );
+        
+        Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult =  groupTypeOperation.addGroupType(groupTypeDefinition, true);
+        assertEquals("check group type added", true, addGroupTypeResult.isLeft());
+        compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value());
+        
+        Either<GroupTypeData, TitanOperationStatus> groupTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), groupTypeDefinition.getType(), GroupTypeData.class);
+        GroupTypeData groupTypeNode = extractVal(groupTypeResult);
+        
+        Either<Edge, TitanOperationStatus> edgeCapTypeResult = titanDao.getEdgeByNodes(groupTypeNode, capabilityTypeNode, GraphEdgeLabels.GROUP_TYPE_CAPABILITY_TYPE);
+        validate(edgeCapTypeResult);
+        
+        Either<Edge, TitanOperationStatus> edgeDerivedFromResult = titanDao.getEdgeByNodes(groupTypeNode, rootNode, GraphEdgeLabels.DERIVED_FROM);
+        validate(edgeDerivedFromResult);
+    }
+    
+    @Test
+    public void testUpgradeGroupTypeWithDerrivedFromEdge() {
+        GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
+        groupTypeDefinition.setDerivedFrom(TOSCA_GROUPS_ROOT);
+        groupTypeDefinition.setDescription("groups l2-networks in network collection");
+        groupTypeDefinition.setType("org.openecomp.groups.PrivateCollection");
+        groupTypeDefinition.setVersion("1.0");
+        
+        List<PropertyDefinition> properties = singletonList(
+                buildProperty("network_collection_type", "l2-network", "network collection type, defined with default value"));
+        
+        groupTypeDefinition.setProperties(properties );
+        
+        Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult =  groupTypeOperation.addGroupType(groupTypeDefinition, true);
+        assertEquals("check group type added", true, addGroupTypeResult.isLeft());
+        compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value());
+        
+        addGroupTypeResult = groupTypeOperation.getGroupTypeByTypeAndVersion("org.openecomp.groups.PrivateCollection", "1.0");
+        assertEquals("check group type added", true, addGroupTypeResult.isLeft());
+        compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value());
+ 
+        Either<GroupTypeDefinition, StorageOperationStatus> upgradeResult = groupTypeOperation.upgradeGroupType(groupTypeDefinition, groupTypeDefinition, true);
+        assertNotNull(upgradeResult);
+        assertTrue(upgradeResult.isLeft());
+    }
+    
+    @Test
+    public void testUpgradeNonExistingGroupType() {
+        GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
+        groupTypeDefinition.setDerivedFrom(TOSCA_GROUPS_ROOT);
+        groupTypeDefinition.setDescription("groups l2-networks in network collection");
+        groupTypeDefinition.setType("org.openecomp.groups.MyCollection");
+        groupTypeDefinition.setVersion("1.0");
+                             
+        Either<GroupTypeDefinition, StorageOperationStatus> upgradeResult = groupTypeOperation.upgradeGroupType(groupTypeDefinition, groupTypeDefinition, true);
+        assertNotNull(upgradeResult);
+        assertTrue(upgradeResult.isRight());
+    }
+    
+    @Test
+    public void testUpgradeNotDerivedGroupType() {
+        GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
+        groupTypeDefinition.setDescription("groups social-networks in school");
+        groupTypeDefinition.setType("org.openecomp.groups.Teachers");
+        groupTypeDefinition.setVersion("1.0");
+        
+        Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult =  groupTypeOperation.addGroupType(groupTypeDefinition, true);
+        assertEquals("check group type added", true, addGroupTypeResult.isLeft());
+        compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value());
+              
+        Either<GroupTypeDefinition, StorageOperationStatus> upgradeResult = groupTypeOperation.upgradeGroupType(groupTypeDefinition, groupTypeDefinition, true);
+        assertNotNull(upgradeResult);
+        assertTrue(upgradeResult.isLeft());
+        assertEquals(groupTypeDefinition, upgradeResult.left().value());
+    }
+    
+    @Test
+    public void testUpgradeGroupTypeWithNonExistingParent() {
+        GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
+        groupTypeDefinition.setDescription("groups social-networks in work");
+        groupTypeDefinition.setType("org.openecomp.groups.Cowokers");
+        groupTypeDefinition.setVersion("1.0");
+        
+        Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult =  groupTypeOperation.addGroupType(groupTypeDefinition, true);
+        assertEquals("check group type added", true, addGroupTypeResult.isLeft());
+        compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value());
+              
+        groupTypeDefinition.setDerivedFrom("Non.existing.parent");
+        Either<GroupTypeDefinition, StorageOperationStatus> upgradeResult = groupTypeOperation.upgradeGroupType(groupTypeDefinition, groupTypeDefinition, true);
+        assertNotNull(upgradeResult);
+        assertTrue(upgradeResult.isRight());
+    }
+    
+    @Test
+    public void testUpgradeGroupType() {
+        GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
+        groupTypeDefinition.setDescription("groups social-networks in university");
+        groupTypeDefinition.setType("org.openecomp.groups.Students");
+        groupTypeDefinition.setVersion("1.0");
+        
+        Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult =  groupTypeOperation.addGroupType(groupTypeDefinition, true);
+        assertEquals("check group type added", true, addGroupTypeResult.isLeft());
+        compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value());
+        
+        GroupTypeDefinition parentGroupTypeDefinition = new GroupTypeDefinition();
+        parentGroupTypeDefinition.setDescription("groups social-networks in university");
+        parentGroupTypeDefinition.setType("org.openecomp.groups.Parents");
+        parentGroupTypeDefinition.setVersion("1.0");
+        
+        Either<GroupTypeDefinition, StorageOperationStatus> addParentGroupTypeResult =  groupTypeOperation.addGroupType(parentGroupTypeDefinition, true);
+        assertEquals("check group type added", true, addParentGroupTypeResult.isLeft());
+        compareBetweenCreatedToSent(parentGroupTypeDefinition, addParentGroupTypeResult.left().value());
+              
+        groupTypeDefinition.setDerivedFrom("org.openecomp.groups.Parents");
+        Either<GroupTypeDefinition, StorageOperationStatus> upgradeResult = groupTypeOperation.upgradeGroupType(groupTypeDefinition, groupTypeDefinition, true);
+        assertNotNull(upgradeResult);
+        assertTrue(upgradeResult.isLeft());
+        assertEquals(groupTypeDefinition, upgradeResult.left().value());
+    }
+    
+    
+    private GroupTypeData getOrCreateRootGroupTypeNode() {
+        Either<GroupTypeData, TitanOperationStatus> groupTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), TOSCA_GROUPS_ROOT, GroupTypeData.class);
+        if(groupTypeResult.isLeft()) {
+            return groupTypeResult.left().value();
+        }
+        
+        return createRootGroupTypeNode();
+    }
+    
+    private GroupTypeData createRootGroupTypeNode() {
+        GroupTypeDefinition rootGroupDefinition = createRootGroupDefinition();
+        Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult =  groupTypeOperation.addGroupType(rootGroupDefinition, true);
+        assertEquals("check group type added", true, addGroupTypeResult.isLeft());
+        
+        Either<GroupTypeData, TitanOperationStatus> groupTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), rootGroupDefinition.getType(), GroupTypeData.class);
+        return extractVal(groupTypeResult);        
+    }
+    
+    private GroupTypeDefinition createRootGroupDefinition() {
+        GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
+        groupTypeDefinition.setDescription("The TOSCA Group Type all other TOSCA Group Types derive from");
+        groupTypeDefinition.setType(TOSCA_GROUPS_ROOT);
+        return groupTypeDefinition;
+    }
+
+    private GroupTypeDefinition createGroupType(String type) {
+        GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition();
+        groupTypeDefinition.setDescription("description for type " + type);
+        groupTypeDefinition.setType(type);
+        return groupTypeDefinition;
+    }
+    
+    private CapabilityTypeDefinition createCapabilityType() {
+        CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition();
+        capabilityTypeDefinition.setDescription("ability to expose routing information of the internal network");
+        capabilityTypeDefinition.setType("org.openecomp.capabilities.VLANAssignment");
+        capabilityTypeDefinition.setVersion("1.0");
+        
+        Map<String, PropertyDefinition> properties = new HashMap<>();
+        properties.put("vfc_instance_group_reference",
+                buildProperty("vfc_instance_group_reference", null, "Ability to recognize capability per vfc instance group on vnf instance"));
+ 
+        capabilityTypeDefinition.setProperties(properties);
+
+        Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityTypeResult = capabilityTypeOperation.addCapabilityType(capabilityTypeDefinition, true);
+        assertEquals("check capability type added", true, addCapabilityTypeResult.isLeft());
+
+        CapabilityTypeDefinition capabilityTypeAdded = addCapabilityTypeResult.left().value();
+        compareBetweenCreatedToSent(capabilityTypeDefinition, capabilityTypeAdded);
+        
+        return capabilityTypeDefinition;
+    }
+    
+    private PropertyDefinition buildProperty(String name, String defaultValue, String description) {
+        PropertyDefinition property = new PropertyDefinition();
+        property.setName(name);
+        property.setDefaultValue(defaultValue);
+        property.setRequired(true);
+        property.setDescription(description);
+        property.setType(ToscaType.STRING.name().toLowerCase());
+
+        return property;
+    }
+    
+    private void compareBetweenCreatedToSent(CapabilityTypeDefinition expected, CapabilityTypeDefinition actual) {
+        assertEquals(expected.getDerivedFrom(), actual.getDerivedFrom());
+        assertEquals(expected.getType(), actual.getType());
+        assertEquals(expected.getDescription(), actual.getDescription());
+    }
+    
+    private void compareBetweenCreatedToSent(GroupTypeDefinition expected, GroupTypeDefinition actual) {
+        assertEquals(expected.getType(), actual.getType());
+        assertEquals(expected.getDescription(), actual.getDescription());
+    }
+    
+    private <T> void validate(Either<T, TitanOperationStatus> result) {
+        extractVal(result);
+    }
+    
+    private <T> T extractVal(Either<T, TitanOperationStatus> result) {
+        assertTrue(result.isLeft());
+        T t = result.left().value();
+        assertNotNull(t);
+        
+        return t;
+    }
+    
+}
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/HeatParametersOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/HeatParametersOperationTest.java
index 8b4ebbdaf8..05b9ec1b89 100644
--- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/HeatParametersOperationTest.java
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/HeatParametersOperationTest.java
@@ -20,13 +20,12 @@
 
 package org.openecomp.sdc.be.model.operations.impl;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.*;
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyMap;
-import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.Matchers.anyMap;
+import static org.mockito.Matchers.anyObject;
+import static org.mockito.Matchers.eq;
 import static org.mockito.Mockito.when;
 
 import java.util.ArrayList;
@@ -45,6 +44,7 @@ import org.openecomp.sdc.be.model.HeatParameterDefinition;
 import org.openecomp.sdc.be.model.ModelTestBase;
 import org.openecomp.sdc.be.model.heat.HeatParameterType;
 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.HeatParametersOperation;
 import org.openecomp.sdc.be.resources.data.HeatParameterData;
 import org.openecomp.sdc.be.resources.data.HeatParameterValueData;
 
@@ -103,7 +103,7 @@ public class HeatParametersOperationTest extends ModelTestBase {
 		Either<GraphRelation, TitanOperationStatus> relationResult = Either.left(graphRelation);
 
 		when(titanGenericDao.createNode(any(HeatParameterData.class), eq(HeatParameterData.class))).thenReturn(either);
-		when(titanGenericDao.createRelation(any(GraphNode.class), any(GraphNode.class), eq(GraphEdgeLabels.HEAT_PARAMETER), anyMap())).thenReturn(relationResult);
+		when(titanGenericDao.createRelation(any(GraphNode.class), (GraphNode) any(GraphNode.class), eq(GraphEdgeLabels.HEAT_PARAMETER), anyMap())).thenReturn(relationResult);
 
 		StorageOperationStatus result = heatParametersOperation.addPropertiesToGraph(parameters, "resourceId.artifactId", NodeTypeEnum.ArtifactRef);
 
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PolicyTypeOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PolicyTypeOperationTest.java
index 516ee51bab..c7e59006cf 100644
--- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PolicyTypeOperationTest.java
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PolicyTypeOperationTest.java
@@ -20,40 +20,51 @@
 
 package org.openecomp.sdc.be.model.operations.impl;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
-import java.util.Iterator;
-
-import javax.annotation.Resource;
-
+import com.thinkaurelius.titan.core.TitanGraph;
+import com.thinkaurelius.titan.core.TitanVertex;
+import fj.data.Either;
 import org.apache.commons.lang.StringUtils;
+import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
+import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
 import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
 import org.openecomp.sdc.be.datatypes.elements.PolicyTypeDataDefinition;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
 import org.openecomp.sdc.be.model.ModelTestBase;
 import org.openecomp.sdc.be.model.PolicyTypeDefinition;
+import org.openecomp.sdc.be.model.PropertyDefinition;
 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.resources.data.PolicyTypeData;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
-import com.thinkaurelius.titan.core.TitanGraph;
-import com.thinkaurelius.titan.core.TitanVertex;
+import java.util.Iterator;
+import java.util.List;
+import java.util.stream.Stream;
 
-import fj.data.Either;
+import static com.google.common.collect.Sets.newHashSet;
+import static java.util.Arrays.asList;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration("classpath:application-context-test.xml")
-
 public class PolicyTypeOperationTest extends ModelTestBase {
 
-	@Resource(name = "policy-type-operation")
+	private static final String NULL_STRING = null;
+	@Autowired
 	private PolicyTypeOperation policyTypeOperation;
 
+	@Autowired
+	private TitanGenericDao titanGenericDao;
+
 	@BeforeClass
 	public static void setupBeforeClass() {
 		ModelTestBase.init();
@@ -99,17 +110,269 @@ public class PolicyTypeOperationTest extends ModelTestBase {
 		assertTrue(eitherPolicyTypeFetched.isLeft());
 		PolicyTypeDefinition policyTypeFetched = eitherPolicyTypeFetched.left().value();
 		assertEquals(policyTypeFetched.toString(), policyTypeCreated.toString());
+	}
+
+	@Test
+	public void testGetLatestPolicyTypeByType_derivedFromFetchedCorrectly() {
+		PolicyTypeDefinition rootPolicyType = createRootPolicyTypeOnGraph();
+		String derivedFromRootType = rootPolicyType.getType();
+		PolicyTypeDefinition policyType1 = createPolicyTypeDef("tosca.policies.type1", "desc1", derivedFromRootType);
+		policyTypeOperation.addPolicyType(policyType1);
+		Either<PolicyTypeDefinition, StorageOperationStatus> eitherPolicyTypeFetched = policyTypeOperation.getLatestPolicyTypeByType(policyType1.getType());
+		assertThat(eitherPolicyTypeFetched.left().value().getDerivedFrom()).isEqualTo(rootPolicyType.getType());
+	}
+
+	@Test
+	public void testGetLatestPolicyTypeByType_whenGettingTypeGetPropertiesFromAllDerivedFromChain_policyTypeHasNoDirectProps() {
+		PropertyDefinition prop1 = createSimpleProperty("val1", "prop1", "string");
+		PropertyDefinition prop2 = createSimpleProperty("val2", "prop2", "string");
+		PolicyTypeDefinition policyType1 = createPolicyTypeDef("tosca.policies.type1", null, prop1, prop2);
+		PolicyTypeDefinition policyType2 = createPolicyTypeDef("tosca.policies.type2", "desc3", policyType1.getType(), null);
+		addPolicyTypesToDB(policyType1, policyType2);
+		Either<PolicyTypeDefinition, StorageOperationStatus> latestPolicyType2 = policyTypeOperation.getLatestPolicyTypeByType(policyType2.getType());
+		assertThat(latestPolicyType2.isLeft());
+		assertThat(latestPolicyType2.left().value().getProperties())
+				.usingElementComparatorOnFields("defaultValue", "name", "type")
+				.containsExactlyInAnyOrder(prop1, prop2);
+	}
+
+	@Test
+	public void testGetLatestPolicyTypeByType_whenGettingTypeGetPropertiesFromAllDerivedFromChain() {
+		PropertyDefinition prop1 = createSimpleProperty("val1", "prop1", "string");
+		PropertyDefinition prop2 = createSimpleProperty("val2", "prop2", "string");
+		PropertyDefinition prop3 = createSimpleProperty("val3", "prop3", "string");
+
+		PolicyTypeDefinition rootPolicyType = createPolicyTypeDef(prop1);
+		PolicyTypeDefinition policyType1 = createPolicyTypeDef("tosca.policies.type1", "desc1", rootPolicyType.getType(), null);
+		PolicyTypeDefinition policyType2 = createPolicyTypeDef("tosca.policies.type2", "desc2", policyType1.getType(), prop2);
+		PolicyTypeDefinition policyType3 = createPolicyTypeDef("tosca.policies.type3", "desc3", policyType2.getType(), null);
+		PolicyTypeDefinition policyType4 = createPolicyTypeDef("tosca.policies.type4", "desc4", policyType3.getType(), prop3);
+
+		addPolicyTypesToDB(rootPolicyType, policyType1, policyType2, policyType3, policyType4);
+
+		Either<PolicyTypeDefinition, StorageOperationStatus> latestPolicyType3 = policyTypeOperation.getLatestPolicyTypeByType(policyType4.getType());
+		assertThat(latestPolicyType3.isLeft());
+		assertThat(latestPolicyType3.left().value().getProperties())
+				.usingElementComparatorOnFields("defaultValue", "name", "type")
+				.containsExactlyInAnyOrder(prop1, prop2, prop3);
+	}
+
+	@Test
+	public void getAllPolicyTypes_noPolicies() {
+		Either<List<PolicyTypeDefinition>, StorageOperationStatus> allPolicyTypes = policyTypeOperation.getAllPolicyTypes(null);
+		assertThat(allPolicyTypes.isRight());
+		assertThat(allPolicyTypes.right().value()).isEqualTo(StorageOperationStatus.NOT_FOUND);
+	}
+
+	@Test
+	public void getAllPolicyTypes() {
+		PolicyTypeDefinition policyType1 = createPolicyTypeDef();
+		PolicyTypeDefinition policyType2 = createPolicyTypeDef("tosca.policies.test1", "desc1", "tosca.policies.Root");
+		addPolicyTypesToDB(policyType1, policyType2);
+		Either<List<PolicyTypeDefinition>, StorageOperationStatus> allPolicyTypesWithNoExcluded = policyTypeOperation.getAllPolicyTypes(null);
+		assertThat(allPolicyTypesWithNoExcluded.left().value()).hasSize(2);
+		assertThat(allPolicyTypesWithNoExcluded.left().value()).usingElementComparatorOnFields("uniqueId", "description", "version", "type")
+				.containsExactlyInAnyOrder(policyType1, policyType2);
+	}
+
+	@Test
+	public void getAllPolicyTypes_whenPassingExcludedTypeList_dontReturnExcludedTypes() {
+		PolicyTypeDefinition policyType1 = createPolicyTypeDef();
+		PolicyTypeDefinition policyType2 = createPolicyTypeDef("tosca.policies.test1", "desc1", "tosca.policies.Root");
+		PolicyTypeDefinition policyType3 = createPolicyTypeDef("tosca.policies.test2", "desc2", "tosca.policies.Root");
+		policyTypeOperation.addPolicyType(policyType1);
+		policyTypeOperation.addPolicyType(policyType2);
+		policyTypeOperation.addPolicyType(policyType3);
+		Either<List<PolicyTypeDefinition>, StorageOperationStatus> allPolicyTypes = policyTypeOperation.getAllPolicyTypes(newHashSet("tosca.policies.test1", "tosca.policies.test2"));
+		assertThat(allPolicyTypes.left().value()).hasSize(1);
+		assertThat(allPolicyTypes.left().value()).usingElementComparatorOnFields("type")
+												 .containsExactly(policyType1);
+	}
+
+	@Test
+    public void addPolicyType_whenDerivedFromNodeNotExist_returnNotFound() {
+        PolicyTypeDefinition type1 = createPolicyTypeDef("tosca.policies.type1", "desc1", "derivedFrom");
+        Either<PolicyTypeDefinition, StorageOperationStatus> addedPolicyTypeResult = policyTypeOperation.addPolicyType(type1);
+        assertThat(addedPolicyTypeResult.right().value()).isEqualTo(StorageOperationStatus.NOT_FOUND);
+    }
+
+    @Test//bug379696
+	public void addPolicyType_derivedFromAddedCorrectly() {
+        PolicyTypeDefinition rootPolicyType = createRootPolicyTypeOnGraph();
+        String derivedFromRootType = rootPolicyType.getType();
+        PolicyTypeDefinition policyType1 = createPolicyTypeDef("tosca.policies.type1", "desc1", derivedFromRootType);
+        Either<PolicyTypeDefinition, StorageOperationStatus> addedPolicyTypeResult = policyTypeOperation.addPolicyType(policyType1);
+        assertThat(addedPolicyTypeResult.isLeft()).isTrue();
+
+        Either<PolicyTypeDefinition, StorageOperationStatus> fetchedPolicyType = policyTypeOperation.getLatestPolicyTypeByType(policyType1.getType());
+		PolicyTypeDefinition fetchedPolicyTypeVal = fetchedPolicyType.left().value();
+		assertThat(fetchedPolicyTypeVal.getDerivedFrom()).isEqualTo(derivedFromRootType);
+		verifyDerivedFromNodeEqualsToRootPolicyType(rootPolicyType, fetchedPolicyTypeVal.getUniqueId());
+
+	}
+
+	@Test
+	public void updatePolicyType_returnNotFoundErrorIfTryingToUpdateANonExistingType() {
+		PolicyTypeDefinition currType = createPolicyTypeDef();
+		PolicyTypeDefinition updatedType = createPolicyTypeDef();
+		Either<PolicyTypeDefinition, StorageOperationStatus> updatePolicyTypeRes = policyTypeOperation.updatePolicyType(updatedType, currType);
+		assertThat(updatePolicyTypeRes.right().value()).isEqualTo(StorageOperationStatus.NOT_FOUND);
+	}
 
+	@Test
+	public void updatePolicyType_basicFields() {
+		PolicyTypeDefinition createdType = createPolicyTypeDef("type1", "description1", NULL_STRING);
+		Either<PolicyTypeDefinition, StorageOperationStatus> currPolicyType = policyTypeOperation.addPolicyType(createdType);
+
+		PolicyTypeDefinition updatedType = createPolicyTypeDef("type1", "description2", NULL_STRING);
+		policyTypeOperation.updatePolicyType(updatedType, currPolicyType.left().value());
+
+		Either<PolicyTypeDefinition, StorageOperationStatus> fetchedUpdatedType = policyTypeOperation.getLatestPolicyTypeByType(createdType.getType());
+		PolicyTypeDefinition fetchedPolicyType = fetchedUpdatedType.left().value();
+		assertThat(fetchedPolicyType.getProperties()).isEmpty();
+		assertThat(fetchedPolicyType)
+				.isEqualToIgnoringGivenFields(updatedType, "properties");
+
+	}
+
+	@Test
+	public void updatePolicyType_updateProperties() {
+		PropertyDefinition prop1 = createSimpleProperty("val1", "prop1", "string");
+		PolicyTypeDefinition policyType = createPolicyTypeDef(prop1);
+		Either<PolicyTypeDefinition, StorageOperationStatus> currPolicyType = policyTypeOperation.addPolicyType(policyType);
+
+		PropertyDefinition updatedProp1 = duplicateProperty(prop1, "newVal1", "int");
+		PropertyDefinition prop2 = createSimpleProperty("val2", "prop2", "string");
+		PolicyTypeDefinition updatedPolicyType = createPolicyTypeDef(updatedProp1, prop2);
+
+		policyTypeOperation.updatePolicyType(updatedPolicyType, currPolicyType.left().value());
+
+		Either<PolicyTypeDefinition, StorageOperationStatus> fetchedUpdatedType = policyTypeOperation.getLatestPolicyTypeByType(policyType.getType());
+		assertThat(fetchedUpdatedType.left().value().getProperties())
+				.usingElementComparatorOnFields("name", "defaultValue", "type")
+				.containsExactlyInAnyOrder(updatedProp1, prop2);
+
+	}
+
+	@Test
+	public void updatePolicyType_derivedFrom_whenNoPrevDerivedFrom_updateToNewDerivedFrom() {
+		PolicyTypeDefinition rootPolicyType = createPolicyTypeDef();
+		PolicyTypeDefinition policyType1 = createPolicyTypeDef("type1", "descr", NULL_STRING);
+		PolicyTypeDefinition updatedPolicyType = createPolicyTypeDef("type1", "descr", rootPolicyType.getType());
+		policyTypeOperation.addPolicyType(rootPolicyType);
+		Either<PolicyTypeDefinition, StorageOperationStatus> currPolicyType = policyTypeOperation.addPolicyType(policyType1);
+		policyTypeOperation.updatePolicyType(updatedPolicyType, currPolicyType.left().value());
+
+		Either<PolicyTypeDefinition, StorageOperationStatus> latestPolicyType = policyTypeOperation.getLatestPolicyTypeByType(policyType1.getType());
+		assertThat(latestPolicyType.left().value().getDerivedFrom()).isEqualTo(rootPolicyType.getType());
+		verifyDerivedFromNodeEqualsToRootPolicyType(rootPolicyType, latestPolicyType.left().value().getUniqueId());
+	}
+
+	@Test
+	public void updatePolicyType_derivedFrom_updateToNullDerivedFrom_derivedFromDeleted() {
+		PolicyTypeDefinition rootPolicyType = createPolicyTypeDef();
+		PolicyTypeDefinition policyType1 = createPolicyTypeDef("type1", "descr", rootPolicyType.getType());
+		PolicyTypeDefinition updatedPolicyType = createPolicyTypeDef("type1", "descr", null, new PropertyDefinition[]{});
+		policyTypeOperation.addPolicyType(rootPolicyType);
+		Either<PolicyTypeDefinition, StorageOperationStatus> currPolicyType = policyTypeOperation.addPolicyType(policyType1);
+
+		policyTypeOperation.updatePolicyType(updatedPolicyType, currPolicyType.left().value());
+
+		Either<PolicyTypeDefinition, StorageOperationStatus> latestPolicyType = policyTypeOperation.getLatestPolicyTypeByType(policyType1.getType());
+		assertThat(latestPolicyType.left().value().getDerivedFrom()).isNull();
+		verifyDerivedFromRelationDoesntExist(latestPolicyType.left().value().getUniqueId());
+	}
+
+	@Test
+	public void updatePolicyType_updateDerivedFrom() {
+		PolicyTypeDefinition rootPolicyType = createPolicyTypeDef();
+		PolicyTypeDefinition derivedType1 = createPolicyTypeDef("derivedType1", "descr", NULL_STRING);
+		PolicyTypeDefinition policyType1 = createPolicyTypeDef("type1", "descr", derivedType1.getType());
+		PolicyTypeDefinition updatedPolicyType = createPolicyTypeDef("type1", "descr", rootPolicyType.getType());
+
+		policyTypeOperation.addPolicyType(rootPolicyType);
+		policyTypeOperation.addPolicyType(derivedType1);
+		Either<PolicyTypeDefinition, StorageOperationStatus> currPolicyType = policyTypeOperation.addPolicyType(policyType1);
+
+		policyTypeOperation.updatePolicyType(updatedPolicyType, currPolicyType.left().value());
+
+		Either<PolicyTypeDefinition, StorageOperationStatus> latestPolicyType = policyTypeOperation.getLatestPolicyTypeByType(policyType1.getType());
+		assertThat(latestPolicyType.left().value().getDerivedFrom()).isEqualTo(rootPolicyType.getType());
+		verifyDerivedFromNodeEqualsToRootPolicyType(rootPolicyType, latestPolicyType.left().value().getUniqueId());
+	}
+
+	private PropertyDefinition duplicateProperty(PropertyDefinition prop1, String updatedValue, String updatedType) {
+		PropertyDefinition updatedProp1 = new PropertyDefinition(prop1);
+		updatedProp1.setUniqueId(null);
+		updatedProp1.setDefaultValue(updatedValue);
+		updatedProp1.setType(updatedType);
+		return updatedProp1;
+	}
+
+	private PropertyDefinition createSimpleProperty(String defaultValue, String name, String type) {
+		PropertyDefinition prop1 = new PropertyDefinition();
+		prop1.setDefaultValue(defaultValue);
+		prop1.setName(name);
+		prop1.setType(type);
+		return prop1;
 	}
 
+	private void verifyDerivedFromNodeEqualsToRootPolicyType(PolicyTypeDefinition rootPolicyType, String parentPolicyId) {
+		Either<ImmutablePair<PolicyTypeData, GraphEdge>, TitanOperationStatus> derivedFromRelation = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.PolicyType), parentPolicyId, GraphEdgeLabels.DERIVED_FROM,
+				NodeTypeEnum.PolicyType, PolicyTypeData.class);
+		assertThat(derivedFromRelation.left().value().getLeft().getPolicyTypeDataDefinition())
+				.isEqualToComparingFieldByField(rootPolicyType);
+	}
+
+	private void verifyDerivedFromRelationDoesntExist(String parentPolicyId) {
+		Either<ImmutablePair<PolicyTypeData, GraphEdge>, TitanOperationStatus> derivedFromRelation = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.PolicyType), parentPolicyId, GraphEdgeLabels.DERIVED_FROM,
+				NodeTypeEnum.PolicyType, PolicyTypeData.class);
+		assertThat(derivedFromRelation.right().value())
+				.isEqualTo(TitanOperationStatus.NOT_FOUND);
+	}
+
+	private PolicyTypeDefinition createRootPolicyTypeOnGraph() {
+        PolicyTypeDefinition rootPolicyType = createPolicyTypeDef();
+        policyTypeOperation.addPolicyType(rootPolicyType);
+        return rootPolicyType;
+
+    }
+
 	private PolicyTypeDefinition createPolicyTypeDef() {
+		return createPolicyTypeDef("tosca.policies.Root", "description: The TOSCA Policy Type all other TOSCA Policy Types derive from", null, new PropertyDefinition[]{});
+	}
+
+	private PolicyTypeDefinition createPolicyTypeDef(PropertyDefinition ... props) {
+		return createPolicyTypeDef("tosca.policies.Root",  null, props);
+	}
+
+	private PolicyTypeDefinition createPolicyTypeDef(String type, String derivedFrom, PropertyDefinition ... props) {
+		PolicyTypeDefinition policyType = createPolicyTypeDef(type, "description: The TOSCA Policy Type all other TOSCA Policy Types derive from", derivedFrom);
+		policyType.setProperties(asList(props));
+		return policyType;
+	}
+
+	private PolicyTypeDefinition createPolicyTypeDef(String type, String description, String derivedFrom) {
+		return createPolicyTypeDef(type, description, derivedFrom, null);
+	}
+
+	private PolicyTypeDefinition createPolicyTypeDef(String type, String description, String derivedFrom,  PropertyDefinition ... props) {
 		PolicyTypeDataDefinition policyTypeDataDefinition = new PolicyTypeDataDefinition();
-		policyTypeDataDefinition.setDescription("description: The TOSCA Policy Type all other TOSCA Policy Types derive from");
-		policyTypeDataDefinition.setType("tosca.policies.Root");
+		policyTypeDataDefinition.setDescription(description);
+		policyTypeDataDefinition.setType(type);
+		policyTypeDataDefinition.setDerivedFrom(derivedFrom);
 		PolicyTypeDefinition policyTypeDefinition = new PolicyTypeDefinition(policyTypeDataDefinition);
 		policyTypeDefinition.setHighestVersion(true);
 		policyTypeDefinition.setVersion("1.0");
+		if (props != null) {
+			policyTypeDefinition.setProperties(asList(props));
+		}
 		return policyTypeDefinition;
 	}
 
+	private void addPolicyTypesToDB(PolicyTypeDefinition ... policyTypeDefinitions) {
+		Stream.of(policyTypeDefinitions).forEach(policyTypeOperation::addPolicyType);
+	}
+
+
 }
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PropertyOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PropertyOperationTest.java
index d862c56790..88f3a24b5d 100644
--- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PropertyOperationTest.java
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PropertyOperationTest.java
@@ -20,19 +20,6 @@
 
 package org.openecomp.sdc.be.model.operations.impl;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.Mockito;
@@ -48,11 +35,21 @@ import org.openecomp.sdc.be.model.tosca.constraints.GreaterThanConstraint;
 import org.openecomp.sdc.be.model.tosca.constraints.InRangeConstraint;
 import org.openecomp.sdc.be.model.tosca.constraints.LessOrEqualConstraint;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static org.junit.Assert.*;
+
 public class PropertyOperationTest extends ModelTestBase {
 
 	TitanGenericDao titanGenericDao = Mockito.mock(TitanGenericDao.class);
 	
-	PropertyOperation propertyOperation = new PropertyOperation(titanGenericDao);
+	PropertyOperation propertyOperation = new PropertyOperation(titanGenericDao, null);
 
 	@Before
 	public void setup() {
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ToscaElementLifecycleOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ToscaElementLifecycleOperationTest.java
index 53bd753fa3..6e9fdc2928 100644
--- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ToscaElementLifecycleOperationTest.java
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ToscaElementLifecycleOperationTest.java
@@ -45,6 +45,7 @@ import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
 import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
+import org.openecomp.sdc.be.dao.jsongraph.utils.IdBuilderUtils;
 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
 import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.MapDataDefinition;
@@ -57,6 +58,7 @@ import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
 import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
 import org.openecomp.sdc.be.model.LifecycleStateEnum;
 import org.openecomp.sdc.be.model.ModelTestBase;
+import org.openecomp.sdc.be.model.catalog.CatalogComponent;
 import org.openecomp.sdc.be.model.category.CategoryDefinition;
 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
 import org.openecomp.sdc.be.model.jsontitan.datamodel.NodeType;
@@ -65,6 +67,7 @@ import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement;
 import org.openecomp.sdc.be.model.jsontitan.operations.NodeTypeOperation;
 import org.openecomp.sdc.be.model.jsontitan.operations.TopologyTemplateOperation;
 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaElementLifecycleOperation;
+import org.openecomp.sdc.be.model.jsontitan.utils.GraphTestUtils;
 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
 import org.openecomp.sdc.common.util.ValidationUtils;
 import org.springframework.test.context.ContextConfiguration;
@@ -78,23 +81,23 @@ import fj.data.Either;
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration("classpath:application-context-test.xml")
 public class ToscaElementLifecycleOperationTest extends ModelTestBase {
-	
+
 	@javax.annotation.Resource
 	protected TitanDao titanDao;
 
 	@javax.annotation.Resource
 	private NodeTypeOperation nodeTypeOperation;
-	
+
 	@javax.annotation.Resource
 	private TopologyTemplateOperation topologyTemplateOperation;
-	
+
 	@javax.annotation.Resource
 	private ToscaElementLifecycleOperation lifecycleOperation;
-	
+
 	String categoryName = "category";
 	String subcategory = "mycategory";
 	String outputDirectory = "C:\\Output";
-	
+
 	@Rule
 	public TestName name = new TestName();
 
@@ -102,11 +105,12 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase {
 	public static void initLifecycleOperation() {
 		ModelTestBase.init();
 	}
-	
+
 	private GraphVertex ownerVertex;
 	private GraphVertex modifierVertex;
 	private GraphVertex vfVertex;
 	private GraphVertex serviceVertex;
+	private GraphVertex rootVertex;
 
 	@Before
 	public void setupBefore() {
@@ -114,222 +118,271 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase {
 		createUsers();
 		createResourceCategory();
 		createServiceCategory();
-		createRootNodeType();
+		GraphTestUtils.createRootCatalogVertex(titanDao);
+		rootVertex = createRootNodeType();
 		createNodeType("firstVf");
-		createTopologyTemplate("firstService");
+		serviceVertex = createTopologyTemplate("firstService");
 	}
 
-	
 	@Test
 	public void lifecycleTest() {
-		Either<ToscaElement, StorageOperationStatus> res = lifecycleOperation
-				.checkinToscaELement(LifecycleStateEnum.findState((String) vfVertex.getMetadataProperty(GraphPropertyEnum.STATE)), 
-						vfVertex.getUniqueId(), modifierVertex.getUniqueId(), ownerVertex.getUniqueId());
+		Either<ToscaElement, StorageOperationStatus> res = lifecycleOperation.checkinToscaELement(LifecycleStateEnum.findState((String) vfVertex.getMetadataProperty(GraphPropertyEnum.STATE)), vfVertex.getUniqueId(), modifierVertex.getUniqueId(),
+				ownerVertex.getUniqueId());
 		StorageOperationStatus status;
-		
+
 		assertTrue(res.isLeft());
+		// 1-node type
+		// 2-vf
+		// 3- service
+		verifyInCatalogData(3, null);
+
 		String id = res.left().value().getUniqueId();
-		
+
 		res = lifecycleOperation.checkoutToscaElement(id, ownerVertex.getUniqueId(), modifierVertex.getUniqueId());
 		assertTrue(res.isLeft());
 		id = res.left().value().getUniqueId();
-		
+
+		verifyInCatalogData(3, null);
+
 		PropertyDataDefinition prop55 = new PropertyDataDefinition();
 		prop55.setName("prop55");
 		prop55.setDefaultValue("def55");
-		 
+
 		status = nodeTypeOperation.addToscaDataToToscaElement(id, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop55, JsonPresentationFields.NAME);
 		assertTrue(status == StorageOperationStatus.OK);
-		
+
 		CapabilityDataDefinition cap1 = new CapabilityDataDefinition();
 		cap1.setName("cap1");
 		cap1.setDescription("create");
 		cap1.setUniqueId(UniqueIdBuilder.buildCapabilityUid(id, "cap1"));
-		 
+
 		status = nodeTypeOperation.addToscaDataToToscaElement(id, EdgeLabelEnum.CAPABILITIES, VertexTypeEnum.CAPABILTIES, cap1, JsonPresentationFields.NAME);
 		assertTrue(status == StorageOperationStatus.OK);
-		 
+
 		res = lifecycleOperation.checkinToscaELement(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, id, ownerVertex.getUniqueId(), ownerVertex.getUniqueId());
 		assertTrue(res.isLeft());
 		id = res.left().value().getUniqueId();
-		
+
 		res = lifecycleOperation.checkoutToscaElement(id, ownerVertex.getUniqueId(), ownerVertex.getUniqueId());
 		assertTrue(res.isLeft());
 		id = res.left().value().getUniqueId();
-		
+
 		prop55.setDefaultValue("AAAAAAAA");
 		status = nodeTypeOperation.updateToscaDataOfToscaElement(id, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop55, JsonPresentationFields.NAME);
 		assertTrue(status == StorageOperationStatus.OK);
-		
+
 		cap1.setDescription("update");
-		 
+
 		status = nodeTypeOperation.updateToscaDataOfToscaElement(id, EdgeLabelEnum.CAPABILITIES, VertexTypeEnum.CAPABILTIES, cap1, JsonPresentationFields.NAME);
 		assertTrue(status == StorageOperationStatus.OK);
-		
+
 		PropertyDataDefinition prop66 = new PropertyDataDefinition();
 		prop66.setName("prop66");
 		prop66.setDefaultValue("def66");
-		 
+
 		status = nodeTypeOperation.addToscaDataToToscaElement(id, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop66, JsonPresentationFields.NAME);
 		assertTrue(status == StorageOperationStatus.OK);
-		
+
 		res = lifecycleOperation.requestCertificationToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId());
 		assertTrue(res.isLeft());
 		id = res.left().value().getUniqueId();
-		
+
 		res = lifecycleOperation.startCertificationToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId());
 		assertTrue(res.isLeft());
 		id = res.left().value().getUniqueId();
-		
+
 		res = lifecycleOperation.certifyToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId());
 		assertTrue(res.isLeft());
 		id = res.left().value().getUniqueId();
+
+		verifyInCatalogData(3, null);
 		
 		res = lifecycleOperation.checkoutToscaElement(id, ownerVertex.getUniqueId(), modifierVertex.getUniqueId());
 		assertTrue(res.isLeft());
 		id = res.left().value().getUniqueId();
+
+		verifyInCatalogData(4, null);
 		
 		PropertyDataDefinition prop77 = new PropertyDataDefinition();
 		prop77.setName("prop77");
 		prop77.setDefaultValue("def77");
-		 
+
 		status = nodeTypeOperation.addToscaDataToToscaElement(id, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop77, JsonPresentationFields.NAME);
 		assertTrue(status == StorageOperationStatus.OK);
-		
+
 		res = lifecycleOperation.checkinToscaELement(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, id, ownerVertex.getUniqueId(), ownerVertex.getUniqueId());
 		assertTrue(res.isLeft());
 		id = res.left().value().getUniqueId();
-		
+
 		res = lifecycleOperation.checkoutToscaElement(id, ownerVertex.getUniqueId(), ownerVertex.getUniqueId());
 		assertTrue(res.isLeft());
 		id = res.left().value().getUniqueId();
-		
+
 		PropertyDataDefinition prop88 = new PropertyDataDefinition();
 		prop88.setName("prop88");
 		prop88.setDefaultValue("def88");
-		 
+
 		status = nodeTypeOperation.addToscaDataToToscaElement(id, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop88, JsonPresentationFields.NAME);
 		assertTrue(status == StorageOperationStatus.OK);
-		
+
 		res = lifecycleOperation.requestCertificationToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId());
 		assertTrue(res.isLeft());
 		id = res.left().value().getUniqueId();
-		
+
 		res = lifecycleOperation.startCertificationToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId());
 		assertTrue(res.isLeft());
 		id = res.left().value().getUniqueId();
-		
+
 		res = lifecycleOperation.certifyToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId());
 		assertTrue(res.isLeft());
 		id = res.left().value().getUniqueId();
+		verifyInCatalogData(3, null);
 		
 		res = lifecycleOperation.checkoutToscaElement(id, ownerVertex.getUniqueId(), ownerVertex.getUniqueId());
 		assertTrue(res.isLeft());
 		id = res.left().value().getUniqueId();
+
+		verifyInCatalogData(4, null);
 		
 		PropertyDataDefinition prop99 = new PropertyDataDefinition();
 		prop99.setName("prop99");
 		prop99.setDefaultValue("def99");
-		 
+
 		status = nodeTypeOperation.addToscaDataToToscaElement(id, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop99, JsonPresentationFields.NAME);
 		assertTrue(status == StorageOperationStatus.OK);
-		
+
 		res = lifecycleOperation.requestCertificationToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId());
 		assertTrue(res.isLeft());
 		id = res.left().value().getUniqueId();
-		
+
 		res = lifecycleOperation.startCertificationToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId());
 		assertTrue(res.isLeft());
 		id = res.left().value().getUniqueId();
-		
+
 		status = nodeTypeOperation.deleteToscaDataElement(id, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, "prop99", JsonPresentationFields.NAME);
 		assertTrue(status == StorageOperationStatus.OK);
-		
-		//cancel certification
+
+		// cancel certification
 		res = lifecycleOperation.cancelOrFailCertification(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId(), LifecycleStateEnum.READY_FOR_CERTIFICATION);
 		assertTrue(res.isLeft());
 		id = res.left().value().getUniqueId();
-		
+
 		res = lifecycleOperation.startCertificationToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId());
 		assertTrue(res.isLeft());
 		id = res.left().value().getUniqueId();
-		
-		//fail certification
+
+		// fail certification
 		res = lifecycleOperation.cancelOrFailCertification(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId(), LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
 		assertTrue(res.isLeft());
 		id = res.left().value().getUniqueId();
-		
-		//exportGraphMl(titanDao.getGraph().left().value());
-		
+		verifyInCatalogData(4, null);
+		// exportGraphMl(titanDao.getGraph().left().value());
+
 	}
 
 	@Test
 	public void serviceConformanceLevelTest() {
-		Either<ToscaElement, StorageOperationStatus> res = lifecycleOperation
-				.checkinToscaELement(LifecycleStateEnum.findState((String) serviceVertex.getMetadataProperty(GraphPropertyEnum.STATE)), 
-						serviceVertex.getUniqueId(), modifierVertex.getUniqueId(), ownerVertex.getUniqueId());
-		
+		Either<ToscaElement, StorageOperationStatus> res = lifecycleOperation.checkinToscaELement(LifecycleStateEnum.findState((String) serviceVertex.getMetadataProperty(GraphPropertyEnum.STATE)), serviceVertex.getUniqueId(),
+				modifierVertex.getUniqueId(), ownerVertex.getUniqueId());
+
 		assertTrue(res.isLeft());
 		String id = res.left().value().getUniqueId();
-		
+
 		res = lifecycleOperation.checkoutToscaElement(id, ownerVertex.getUniqueId(), modifierVertex.getUniqueId());
 		assertTrue(res.isLeft());
-		
+
 		String conformanceLevel = res.left().value().getMetadataValue(JsonPresentationFields.CONFORMANCE_LEVEL).toString();
 		assertEquals(conformanceLevel, ModelTestBase.configurationManager.getConfiguration().getToscaConformanceLevel());
 	}
-	
-	private void createResourceCategory() {
+
+	@Test
+	public void catalogTest() {
+		// start position - 3 in catalog
+		List<String> expectedIds = new ArrayList<String>();
+		expectedIds.add(rootVertex.getUniqueId());
+		expectedIds.add(vfVertex.getUniqueId());
+		expectedIds.add(serviceVertex.getUniqueId());
+
+		verifyInCatalogData(3, expectedIds);
 		
+		GraphVertex vertex4 = createTopologyTemplate("topTemp4");
+		expectedIds.add(vertex4.getUniqueId());
+		verifyInCatalogData(4, expectedIds);
+
+		Either<ToscaElement, StorageOperationStatus> res = lifecycleOperation.undoCheckout(vertex4.getUniqueId());
+		expectedIds.remove(vertex4.getUniqueId());
+		verifyInCatalogData(3, expectedIds);
+
+		vertex4 = createTopologyTemplate("topTemp4");
+		expectedIds.add(vertex4.getUniqueId());
+		verifyInCatalogData(4, expectedIds);
+
+		res = lifecycleOperation.checkinToscaELement(LifecycleStateEnum.findState((String) vertex4.getMetadataProperty(GraphPropertyEnum.STATE)), vertex4.getUniqueId(), modifierVertex.getUniqueId(), ownerVertex.getUniqueId());
+		Either<ToscaElement, StorageOperationStatus> certifyToscaElement = lifecycleOperation.certifyToscaElement(vertex4.getUniqueId(), modifierVertex.getUniqueId(), ownerVertex.getUniqueId());
+		assertTrue(certifyToscaElement.isLeft());
+		expectedIds.remove(vertex4.getUniqueId());
+		String certifiedId = certifyToscaElement.left().value().getUniqueId();
+		expectedIds.add(certifiedId);
+		verifyInCatalogData(4, expectedIds);
+		
+		res = lifecycleOperation.checkoutToscaElement(certifiedId, modifierVertex.getUniqueId(), ownerVertex.getUniqueId());
+		assertTrue(certifyToscaElement.isLeft());
+		expectedIds.add(res.left().value().getUniqueId());
+		verifyInCatalogData(5, expectedIds);
+	}
+
+	private void createResourceCategory() {
+
 		GraphVertex cat = new GraphVertex(VertexTypeEnum.RESOURCE_CATEGORY);
 		Map<GraphPropertyEnum, Object> metadataProperties = new HashMap<>();
 		String catId = UniqueIdBuilder.buildComponentCategoryUid(categoryName, VertexTypeEnum.RESOURCE_CATEGORY);
 		cat.setUniqueId(catId);
-		metadataProperties.put(GraphPropertyEnum.UNIQUE_ID,catId);
+		metadataProperties.put(GraphPropertyEnum.UNIQUE_ID, catId);
 		metadataProperties.put(GraphPropertyEnum.LABEL, VertexTypeEnum.RESOURCE_CATEGORY.getName());
-		metadataProperties.put(GraphPropertyEnum.NAME,categoryName);
+		metadataProperties.put(GraphPropertyEnum.NAME, categoryName);
 		metadataProperties.put(GraphPropertyEnum.NORMALIZED_NAME, ValidationUtils.normalizeCategoryName4Uniqueness(categoryName));
 		cat.setMetadataProperties(metadataProperties);
 		cat.updateMetadataJsonWithCurrentMetadataProperties();
-		
+
 		GraphVertex subCat = new GraphVertex(VertexTypeEnum.RESOURCE_SUBCATEGORY);
 		metadataProperties = new HashMap<>();
 		String subCatId = UniqueIdBuilder.buildSubCategoryUid(cat.getUniqueId(), subcategory);
 		subCat.setUniqueId(subCatId);
-		metadataProperties.put(GraphPropertyEnum.UNIQUE_ID,subCatId);
+		metadataProperties.put(GraphPropertyEnum.UNIQUE_ID, subCatId);
 		metadataProperties.put(GraphPropertyEnum.LABEL, VertexTypeEnum.RESOURCE_SUBCATEGORY.getName());
-		metadataProperties.put(GraphPropertyEnum.NAME,subcategory);
+		metadataProperties.put(GraphPropertyEnum.NAME, subcategory);
+		metadataProperties.put(GraphPropertyEnum.NORMALIZED_NAME, ValidationUtils.normalizeCategoryName4Uniqueness(subcategory));
 		subCat.setMetadataProperties(metadataProperties);
 		subCat.updateMetadataJsonWithCurrentMetadataProperties();
-		
+
 		Either<GraphVertex, TitanOperationStatus> catRes = titanDao.createVertex(cat);
-		
+
 		Either<GraphVertex, TitanOperationStatus> subCatRes = titanDao.createVertex(subCat);
-		
+
 		TitanOperationStatus status = titanDao.createEdge(catRes.left().value().getVertex(), subCatRes.left().value().getVertex(), EdgeLabelEnum.SUB_CATEGORY, new HashMap<>());
 		assertEquals(TitanOperationStatus.OK, status);
 	}
-	
+
 	private void createServiceCategory() {
-		
+
 		GraphVertex cat = new GraphVertex(VertexTypeEnum.SERVICE_CATEGORY);
 		Map<GraphPropertyEnum, Object> metadataProperties = new HashMap<>();
 		String catId = UniqueIdBuilder.buildComponentCategoryUid(categoryName, VertexTypeEnum.SERVICE_CATEGORY);
 		cat.setUniqueId(catId);
-		metadataProperties.put(GraphPropertyEnum.UNIQUE_ID,catId);
+		metadataProperties.put(GraphPropertyEnum.UNIQUE_ID, catId);
 		metadataProperties.put(GraphPropertyEnum.LABEL, VertexTypeEnum.SERVICE_CATEGORY.getName());
-		metadataProperties.put(GraphPropertyEnum.NAME,categoryName);
+		metadataProperties.put(GraphPropertyEnum.NAME, categoryName);
 		metadataProperties.put(GraphPropertyEnum.NORMALIZED_NAME, ValidationUtils.normalizeCategoryName4Uniqueness(categoryName));
 		cat.setMetadataProperties(metadataProperties);
 		cat.updateMetadataJsonWithCurrentMetadataProperties();
-				
+
 		Either<GraphVertex, TitanOperationStatus> catRes = titanDao.createVertex(cat);
-			
+
 		assertTrue(catRes.isLeft());
 	}
-	
-	private TopologyTemplate createTopologyTemplate(String name) {
-		
+
+	private GraphVertex createTopologyTemplate(String name) {
+
 		TopologyTemplate service = new TopologyTemplate();
 		String uniqueId = UniqueIdBuilder.buildResourceUniqueId();
 		service.setUniqueId(uniqueId);
@@ -337,28 +390,28 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase {
 		service.getMetadata().put(JsonPresentationFields.NAME.getPresentation(), name);
 		service.getMetadata().put(JsonPresentationFields.UNIQUE_ID.getPresentation(), uniqueId);
 		service.getMetadata().put(JsonPresentationFields.VERSION.getPresentation(), "0.1");
-		service.getMetadata().put(JsonPresentationFields.TYPE.getPresentation(),ResourceTypeEnum.VF.name());
-		service.getMetadata().put(JsonPresentationFields.COMPONENT_TYPE.getPresentation(),ComponentTypeEnum.RESOURCE);
+		service.getMetadata().put(JsonPresentationFields.TYPE.getPresentation(), ResourceTypeEnum.VF.name());
+		service.getMetadata().put(JsonPresentationFields.COMPONENT_TYPE.getPresentation(), ComponentTypeEnum.RESOURCE);
 		List<CategoryDefinition> categories = new ArrayList<>();
 		CategoryDefinition cat = new CategoryDefinition();
 		categories.add(cat);
 		cat.setName(categoryName);
 		service.setCategories(categories);
-		
+
 		service.setComponentType(ComponentTypeEnum.SERVICE);
 		Either<TopologyTemplate, StorageOperationStatus> createRes = topologyTemplateOperation.createTopologyTemplate(service);
 		assertTrue(createRes.isLeft());
-		
-		Either<GraphVertex, TitanOperationStatus> getNodeTyeRes= titanDao.getVertexById(createRes.left().value().getUniqueId());
+
+		Either<GraphVertex, TitanOperationStatus> getNodeTyeRes = titanDao.getVertexById(createRes.left().value().getUniqueId());
 		assertTrue(getNodeTyeRes.isLeft());
-		
-		serviceVertex = getNodeTyeRes.left().value();
-		 
-		return service;
+
+		// serviceVertex = getNodeTyeRes.left().value();
+
+		return getNodeTyeRes.left().value();
 	}
-	
+
 	private <T extends ToscaDataDefinition> NodeType createNodeType(String nodeTypeName) {
-		
+
 		NodeType vf = new NodeType();
 		String uniqueId = UniqueIdBuilder.buildResourceUniqueId();
 		vf.setUniqueId(uniqueId);
@@ -366,8 +419,8 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase {
 		vf.getMetadata().put(JsonPresentationFields.NAME.getPresentation(), nodeTypeName);
 		vf.getMetadata().put(JsonPresentationFields.UNIQUE_ID.getPresentation(), uniqueId);
 		vf.getMetadata().put(JsonPresentationFields.VERSION.getPresentation(), "0.1");
-		vf.getMetadata().put(JsonPresentationFields.TYPE.getPresentation(),ResourceTypeEnum.VF.name());
-		vf.getMetadata().put(JsonPresentationFields.COMPONENT_TYPE.getPresentation(),ComponentTypeEnum.RESOURCE);
+		vf.getMetadata().put(JsonPresentationFields.TYPE.getPresentation(), ResourceTypeEnum.VF.name());
+		vf.getMetadata().put(JsonPresentationFields.COMPONENT_TYPE.getPresentation(), ComponentTypeEnum.RESOURCE);
 		List<CategoryDefinition> categories = new ArrayList<>();
 		CategoryDefinition cat = new CategoryDefinition();
 		categories.add(cat);
@@ -378,95 +431,90 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase {
 		subCategories.add(subCat);
 		cat.setSubcategories(subCategories);
 		vf.setCategories(categories);
-		
-		
+
 		List<String> derivedFrom = new ArrayList<>();
 		derivedFrom.add("root");
 		vf.setDerivedFrom(derivedFrom);
-		
-//		 Map<String, PropertyDataDefinition> properties = new HashMap<>();
-//		 PropertyDataDefinition prop1 = new PropertyDataDefinition();
-//		 prop1.setName("prop1");
-//		 prop1.setDefaultValue("def1");
-//		 
-//		 properties.put("prop1", prop1);
-//		 
-//		 PropertyDataDefinition prop2 = new PropertyDataDefinition();
-//		 prop2.setName("prop2");
-//		 prop2.setDefaultValue("def2");
-//		 properties.put("prop2", prop2);
-//		 
-//		 PropertyDataDefinition prop3 = new PropertyDataDefinition();
-//		 prop3.setName("prop3");
-//		 prop3.setDefaultValue("def3");
-//		 properties.put("prop3", prop3);
-//		 
-//		 vf.setProperties(properties);
-		 vf.setComponentType(ComponentTypeEnum.RESOURCE);
+
+		// Map<String, PropertyDataDefinition> properties = new HashMap<>();
+		// PropertyDataDefinition prop1 = new PropertyDataDefinition();
+		// prop1.setName("prop1");
+		// prop1.setDefaultValue("def1");
+		//
+		// properties.put("prop1", prop1);
+		//
+		// PropertyDataDefinition prop2 = new PropertyDataDefinition();
+		// prop2.setName("prop2");
+		// prop2.setDefaultValue("def2");
+		// properties.put("prop2", prop2);
+		//
+		// PropertyDataDefinition prop3 = new PropertyDataDefinition();
+		// prop3.setName("prop3");
+		// prop3.setDefaultValue("def3");
+		// properties.put("prop3", prop3);
+		//
+		// vf.setProperties(properties);
+		vf.setComponentType(ComponentTypeEnum.RESOURCE);
 		Either<NodeType, StorageOperationStatus> createVFRes = nodeTypeOperation.createNodeType(vf);
 		assertTrue(createVFRes.isLeft());
-		
-		Either<GraphVertex, TitanOperationStatus> getNodeTyeRes= titanDao.getVertexById(createVFRes.left().value().getUniqueId());
+
+		Either<GraphVertex, TitanOperationStatus> getNodeTyeRes = titanDao.getVertexById(createVFRes.left().value().getUniqueId());
 		assertTrue(getNodeTyeRes.isLeft());
-		
+
 		vfVertex = getNodeTyeRes.left().value();
-		
-		
-		
-		 List<PropertyDataDefinition> addProperties = new ArrayList<>();
-		 PropertyDataDefinition prop11 = new PropertyDataDefinition();
-		 prop11.setName("prop11");
-		 prop11.setDefaultValue("def11");
-		 
-		 addProperties.add(prop11);
-		 
-		 PropertyDataDefinition prop22 = new PropertyDataDefinition();
-		 prop22.setName("prop22");
-		 prop22.setDefaultValue("def22");
-		 addProperties.add(prop22);
-		 
-		 StorageOperationStatus status = nodeTypeOperation.addToscaDataToToscaElement(vfVertex, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, addProperties, JsonPresentationFields.NAME);
-		 assertTrue(status == StorageOperationStatus.OK);
-		 
-		 PropertyDataDefinition prop33 = new PropertyDataDefinition();
-		 prop33.setName("prop33");
-		 prop33.setDefaultValue("def33");
-		 
-		 status = nodeTypeOperation.addToscaDataToToscaElement(vfVertex, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop33, JsonPresentationFields.NAME);
-		 assertTrue(status == StorageOperationStatus.OK);
-		 
-		 PropertyDataDefinition prop44 = new PropertyDataDefinition();
-		 prop44.setName("prop44");
-		 prop44.setDefaultValue("def44");
-		 
-		 status = nodeTypeOperation.addToscaDataToToscaElement(vfVertex.getUniqueId(), EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop44, JsonPresentationFields.NAME);
-		 assertTrue(status == StorageOperationStatus.OK);
-		 	
-		 
-		 PropertyDataDefinition capProp = new PropertyDataDefinition();
-		 capProp.setName( "capProp");
-		 capProp.setDefaultValue( "capPropDef");
-		 
-		 MapDataDefinition dataToCreate = new MapPropertiesDataDefinition();		 
-		 dataToCreate.put("capProp", capProp);
-		 
-		 Map<String, MapDataDefinition> capProps = new HashMap();
-		 capProps.put("capName", dataToCreate);	
-		
-		 Either<GraphVertex, StorageOperationStatus> res = nodeTypeOperation.assosiateElementToData(vfVertex,  VertexTypeEnum.CAPABILITIES_PROPERTIES, EdgeLabelEnum.CAPABILITIES_PROPERTIES, capProps);
-		 
+
+		List<PropertyDataDefinition> addProperties = new ArrayList<>();
+		PropertyDataDefinition prop11 = new PropertyDataDefinition();
+		prop11.setName("prop11");
+		prop11.setDefaultValue("def11");
+
+		addProperties.add(prop11);
+
+		PropertyDataDefinition prop22 = new PropertyDataDefinition();
+		prop22.setName("prop22");
+		prop22.setDefaultValue("def22");
+		addProperties.add(prop22);
+
+		StorageOperationStatus status = nodeTypeOperation.addToscaDataToToscaElement(vfVertex, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, addProperties, JsonPresentationFields.NAME);
+		assertTrue(status == StorageOperationStatus.OK);
+
+		PropertyDataDefinition prop33 = new PropertyDataDefinition();
+		prop33.setName("prop33");
+		prop33.setDefaultValue("def33");
+
+		status = nodeTypeOperation.addToscaDataToToscaElement(vfVertex, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop33, JsonPresentationFields.NAME);
+		assertTrue(status == StorageOperationStatus.OK);
+
+		PropertyDataDefinition prop44 = new PropertyDataDefinition();
+		prop44.setName("prop44");
+		prop44.setDefaultValue("def44");
+
+		status = nodeTypeOperation.addToscaDataToToscaElement(vfVertex.getUniqueId(), EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop44, JsonPresentationFields.NAME);
+		assertTrue(status == StorageOperationStatus.OK);
+
+		PropertyDataDefinition capProp = new PropertyDataDefinition();
+		capProp.setName("capProp");
+		capProp.setDefaultValue("capPropDef");
+
+		MapDataDefinition dataToCreate = new MapPropertiesDataDefinition();
+		dataToCreate.put("capProp", capProp);
+
+		Map<String, MapDataDefinition> capProps = new HashMap();
+		capProps.put("capName", dataToCreate);
+
+		Either<GraphVertex, StorageOperationStatus> res = nodeTypeOperation.assosiateElementToData(vfVertex, VertexTypeEnum.CAPABILITIES_PROPERTIES, EdgeLabelEnum.CAPABILITIES_PROPERTIES, capProps);
+
 		// exportGraphMl(titanDao.getGraph().left().value());
-		 
-		 List<String> pathKeys = new ArrayList<>();
-		 pathKeys.add("capName");
-		 capProp.setDefaultValue( "BBBB");
-		 status = nodeTypeOperation.updateToscaDataDeepElementOfToscaElement(vfVertex, EdgeLabelEnum.CAPABILITIES_PROPERTIES, VertexTypeEnum.CAPABILITIES_PROPERTIES,
-				 capProp, pathKeys, JsonPresentationFields.NAME);
+
+		List<String> pathKeys = new ArrayList<>();
+		pathKeys.add("capName");
+		capProp.setDefaultValue("BBBB");
+		status = nodeTypeOperation.updateToscaDataDeepElementOfToscaElement(vfVertex, EdgeLabelEnum.CAPABILITIES_PROPERTIES, VertexTypeEnum.CAPABILITIES_PROPERTIES, capProp, pathKeys, JsonPresentationFields.NAME);
 		return vf;
 	}
-	
-	private void createRootNodeType() {
-		
+
+	private GraphVertex createRootNodeType() {
+
 		NodeType vf = new NodeType();
 		String uniqueId = UniqueIdBuilder.buildResourceUniqueId();
 		vf.setUniqueId(uniqueId);
@@ -475,11 +523,11 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase {
 		vf.getMetadata().put(JsonPresentationFields.NAME.getPresentation(), "root");
 		vf.getMetadata().put(JsonPresentationFields.UNIQUE_ID.getPresentation(), uniqueId);
 		vf.getMetadata().put(JsonPresentationFields.VERSION.getPresentation(), "1.0");
-		vf.getMetadata().put(JsonPresentationFields.TYPE.getPresentation(),ResourceTypeEnum.VFC.name());
+		vf.getMetadata().put(JsonPresentationFields.TYPE.getPresentation(), ResourceTypeEnum.VFC.name());
 		vf.getMetadata().put(JsonPresentationFields.LIFECYCLE_STATE.getPresentation(), LifecycleStateEnum.CERTIFIED.name());
 		vf.getMetadata().put(JsonPresentationFields.TOSCA_RESOURCE_NAME.getPresentation(), "root");
 		vf.getMetadata().put(JsonPresentationFields.HIGHEST_VERSION.getPresentation(), true);
-		
+
 		List<CategoryDefinition> categories = new ArrayList<>();
 		CategoryDefinition cat = new CategoryDefinition();
 		categories.add(cat);
@@ -490,42 +538,42 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase {
 		subCategories.add(subCat);
 		cat.setSubcategories(subCategories);
 		vf.setCategories(categories);
-		
-		
+
 		List<String> derivedFrom = new ArrayList<>();
 		vf.setDerivedFrom(derivedFrom);
-		
-		 Map<String, PropertyDataDefinition> properties = new HashMap<>();
-		 PropertyDataDefinition prop1 = new PropertyDataDefinition();
-		 prop1.setName("derived1");
-		 prop1.setDefaultValue("deriveddef1");
-		 
-		 properties.put("derived1", prop1);
-		 
-		 PropertyDataDefinition prop2 = new PropertyDataDefinition();
-		 prop2.setUniqueId("derived2");
-		 prop2.setName("deriveddef2");
-		 properties.put("derived2", prop2);
-		 
-		 PropertyDataDefinition prop3 = new PropertyDataDefinition();
-		 prop3.setName("derived3");
-		 prop3.setDefaultValue("deriveddef3");
-		 properties.put("derived3", prop3);
-		 
-		 vf.setProperties(properties);
-		 vf.setComponentType(ComponentTypeEnum.RESOURCE);
+
+		Map<String, PropertyDataDefinition> properties = new HashMap<>();
+		PropertyDataDefinition prop1 = new PropertyDataDefinition();
+		prop1.setName("derived1");
+		prop1.setDefaultValue("deriveddef1");
+
+		properties.put("derived1", prop1);
+
+		PropertyDataDefinition prop2 = new PropertyDataDefinition();
+		prop2.setUniqueId("derived2");
+		prop2.setName("deriveddef2");
+		properties.put("derived2", prop2);
+
+		PropertyDataDefinition prop3 = new PropertyDataDefinition();
+		prop3.setName("derived3");
+		prop3.setDefaultValue("deriveddef3");
+		properties.put("derived3", prop3);
+
+		vf.setProperties(properties);
+		vf.setComponentType(ComponentTypeEnum.RESOURCE);
 		Either<NodeType, StorageOperationStatus> createVFRes = nodeTypeOperation.createNodeType(vf);
 		assertTrue(createVFRes.isLeft());
-		
-		Either<GraphVertex, TitanOperationStatus> getNodeTyeRes= titanDao.getVertexById(createVFRes.left().value().getUniqueId());
+
+		Either<GraphVertex, TitanOperationStatus> getNodeTyeRes = titanDao.getVertexById(createVFRes.left().value().getUniqueId());
 		assertTrue(getNodeTyeRes.isLeft());
+		return getNodeTyeRes.left().value();
 	}
 
 	private void createUsers() {
-		
+
 		GraphVertex ownerV = new GraphVertex(VertexTypeEnum.USER);
 		ownerV.setUniqueId("user1");
-				
+
 		Map<GraphPropertyEnum, Object> metadataProperties = new HashMap<>();
 		metadataProperties.put(GraphPropertyEnum.USERID, ownerV.getUniqueId());
 		metadataProperties.put(GraphPropertyEnum.LABEL, VertexTypeEnum.USER.getName());
@@ -535,12 +583,12 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase {
 		ownerV.setJson(new HashMap<>());
 		Either<GraphVertex, TitanOperationStatus> createUserRes = titanDao.createVertex(ownerV);
 		assertTrue(createUserRes.isLeft());
-		
+
 		ownerVertex = createUserRes.left().value();
-		
+
 		GraphVertex modifierV = new GraphVertex(VertexTypeEnum.USER);
 		modifierV.setUniqueId("user2");
-				
+
 		metadataProperties = new HashMap<>();
 		metadataProperties.put(GraphPropertyEnum.USERID, modifierV.getUniqueId());
 		metadataProperties.put(GraphPropertyEnum.LABEL, VertexTypeEnum.USER.getName());
@@ -550,12 +598,24 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase {
 		modifierV.setJson(new HashMap<>());
 		createUserRes = titanDao.createVertex(modifierV);
 		assertTrue(createUserRes.isLeft());
-				
+
 		modifierVertex = createUserRes.left().value();
-			
+
 		Either<GraphVertex, TitanOperationStatus> getOwnerRes = lifecycleOperation.findUser(ownerVertex.getUniqueId());
 		assertTrue(getOwnerRes.isLeft());
-	
+
+	}
+
+	public void verifyInCatalogData(int expected, List<String> expectedIds) {
+
+		Either<List<CatalogComponent>, StorageOperationStatus> highestResourcesRes = topologyTemplateOperation.getElementCatalogData();
+		assertTrue(highestResourcesRes.isLeft());
+		List<CatalogComponent> highestResources = highestResourcesRes.left().value();
+		// calculate expected count value
+		assertEquals(expected, highestResources.stream().count());
+		if (expectedIds != null) {
+			highestResources.forEach(a -> assertTrue(expectedIds.contains(a.getUniqueId())));
+		}
 	}
 
 	@After
@@ -594,5 +654,5 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase {
 		return result;
 
 	}
-	
+
 }
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/converters/DataTypePropertyConverterTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/converters/DataTypePropertyConverterTest.java
index d5425504e6..e15d784c7a 100644
--- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/converters/DataTypePropertyConverterTest.java
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/converters/DataTypePropertyConverterTest.java
@@ -1,19 +1,19 @@
 package org.openecomp.sdc.be.model.tosca.converters;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
+import com.google.gson.JsonObject;
+import org.junit.Before;
+import org.junit.Test;
+import org.openecomp.sdc.be.model.DataTypeDefinition;
+import org.openecomp.sdc.be.model.PropertyDefinition;
 
+import javax.json.Json;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 
-import org.junit.Before;
-import org.junit.Test;
-import org.openecomp.sdc.be.model.DataTypeDefinition;
-import org.openecomp.sdc.be.model.PropertyDefinition;
-
-import com.google.gson.JsonObject;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
 
 public class DataTypePropertyConverterTest {
 
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/converters/ToscaFloatConverterTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/converters/ToscaFloatConverterTest.java
index 5367dcb8a3..7e9388ee1b 100644
--- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/converters/ToscaFloatConverterTest.java
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/converters/ToscaFloatConverterTest.java
@@ -2,22 +2,73 @@ package org.openecomp.sdc.be.model.tosca.converters;
 
 import org.junit.Test;
 
+import java.util.Collections;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.junit.Assert.assertNull;
+
 
 public class ToscaFloatConverterTest {
 
-	private ToscaFloatConverter createTestSubject() {
-		return  ToscaFloatConverter.getInstance();
-	}
+    @Test
+    public void convertEmptyString_returnNull() {
+        assertNull(executeFloatConversion(""));
+    }
+
+    @Test
+    public void convertNull_returnNull() {
+        assertNull(executeFloatConversion(null));
+    }
+
+    @Test
+    public void convertWholeNumber() {
+        assertThat(executeFloatConversion("1234"))
+                .isEqualTo("1234");
+    }
+
+    @Test
+    public void convertFloatNumber() {
+        assertThat(executeFloatConversion("3.141"))
+                .isEqualTo("3.141");
+    }
+
+    @Test
+    public void convertNotValidFloat() {
+        assertThatExceptionOfType(NumberFormatException.class).isThrownBy(() -> executeFloatConversion("123.55.66"));
+    }
+
+    @Test
+    public void convertNumericWithSpecialChars() {
+        assertThatExceptionOfType(NumberFormatException.class).isThrownBy(() -> executeFloatConversion("123,55"));
+        assertThatExceptionOfType(NumberFormatException.class).isThrownBy(() -> executeFloatConversion("123&55"));
+        assertThatExceptionOfType(NumberFormatException.class).isThrownBy(() -> executeFloatConversion("123$$55"));
+        assertThatExceptionOfType(NumberFormatException.class).isThrownBy(() -> executeFloatConversion("123#55"));
+    }
+
+    @Test
+    public void convertNonNumeric() {
+        assertThatExceptionOfType(NumberFormatException.class).isThrownBy(() -> executeFloatConversion("1234ABC"));
+    }
 
-	
-	@Test
-	public void testGetInstance() throws Exception {
-		ToscaFloatConverter result;
+    @Test
+    public void convertNumericWithCapitalFloatSign() {
+        assertThat(executeFloatConversion("1234F"))
+                .isEqualTo("1234");
+    }
 
-		// default test
-		result = ToscaFloatConverter.getInstance();
-	}
+    @Test
+    public void convertNumericWithSmallLetterFloatSign() {
+        assertThat(executeFloatConversion("1234f"))
+                .isEqualTo("1234");
+    }
 
-	
+    @Test
+    public void convertNumericWithFloatSignNotAtTheEnd_ThrowsException() {
+        assertThatExceptionOfType(NumberFormatException.class).isThrownBy(() -> executeFloatConversion("12f34"));
+    }
 
+    private String executeFloatConversion(String s) {
+        return ToscaFloatConverter.getInstance().convert(s, null, Collections.emptyMap());
+    }
 }
\ No newline at end of file
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/validators/MapValidatorTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/validators/MapValidatorTest.java
new file mode 100644
index 0000000000..6f33b19de3
--- /dev/null
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/validators/MapValidatorTest.java
@@ -0,0 +1,16 @@
+package org.openecomp.sdc.be.model.tosca.validators;
+
+import org.junit.Test;
+
+import java.util.Collections;
+
+import static org.junit.Assert.*;
+
+public class MapValidatorTest {
+
+    @Test
+    public void isValid_nonMapString() {
+        assertFalse(MapValidator.getInstance().isValid("abc", "string", Collections.emptyMap()));
+        assertFalse(MapValidator.getInstance().isValid("1", "string", Collections.emptyMap()));
+    }
+}
\ No newline at end of file
diff --git a/catalog-model/src/test/resources/application-context-test.xml b/catalog-model/src/test/resources/application-context-test.xml
index 58de573b55..ccde197a7f 100644
--- a/catalog-model/src/test/resources/application-context-test.xml
+++ b/catalog-model/src/test/resources/application-context-test.xml
@@ -12,7 +12,8 @@
     	org.openecomp.sdc.be.dao.jsongraph,
     	org.openecomp.sdc.be.model.cache,
 		org.openecomp.sdc.be.dao.titan,
-		org.openecomp.sdc.be.dao.cassandra">
+		org.openecomp.sdc.be.dao.cassandra,
+		org.openecomp.sdc.be.model.jsontitan.utils">
    
   </context:component-scan>