gerrit.onap Code Review - sdc.git/blob

   1 /*
   2
   3  * Copyright (c) 2018 AT&T Intellectual Property.
   4
   5  *
   6
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8
   9  * you may not use this file except in compliance with the License.
  10
  11  * You may obtain a copy of the License at
  12
  13  *
  14
  15  *     http://www.apache.org/licenses/LICENSE-2.0
  16
  17  *
  18
  19  * Unless required by applicable law or agreed to in writing, software
  20
  21  * distributed under the License is distributed on an "AS IS" BASIS,
  22
  23  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  24
  25  * See the License for the specific language governing permissions and
  26
  27  * limitations under the License.
  28
  29  */
  30 package org.openecomp.sdc.be.model.jsonjanusgraph.operations;
  31
  32 import fj.data.Either;
  33 import org.apache.commons.collections.map.HashedMap;
  34 import org.apache.commons.lang3.tuple.ImmutablePair;
  35 import org.junit.Before;
  36 import org.junit.Test;
  37 import org.junit.runner.RunWith;
  38 import org.mockito.ArgumentCaptor;
  39 import org.mockito.InjectMocks;
  40 import org.mockito.Mock;
  41 import org.mockito.Mockito;
  42 import org.mockito.ArgumentMatchers;
  43 import org.mockito.MockitoAnnotations;
  44 import org.mockito.junit.MockitoJUnitRunner;
  45 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  46 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  47 import org.openecomp.sdc.be.dao.jsongraph.HealingJanusGraphDao;
  48 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  49 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  50 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  51 import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
  52 import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition;
  53 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  54 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
  55 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  56 import org.openecomp.sdc.be.datatypes.enums.PromoteVersionEnum;
  57 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
  58 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  59 import org.openecomp.sdc.be.model.Component;
  60 import org.openecomp.sdc.be.model.ComponentInstance;
  61 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  62 import org.openecomp.sdc.be.model.Resource;
  63 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  64 import org.openecomp.sdc.be.model.ComponentParametersView;
  65 import org.openecomp.sdc.be.model.PolicyDefinition;
  66 import org.openecomp.sdc.be.model.Service;
  67 import org.openecomp.sdc.be.model.User;
  68 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.NodeType;
  69 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate;
  70 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement;
  71 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElementTypeEnum;
  72 import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter;
  73 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  74 import org.openecomp.sdc.be.model.DataTypeDefinition;
  75 import org.openecomp.sdc.be.model.PropertyDefinition;
  76 import org.openecomp.sdc.be.datatypes.elements.DataTypeDataDefinition;
  77 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
  78 import static org.assertj.core.api.Assertions.assertThat;
  79
  80 import java.util.HashMap;
  81 import java.util.List;
  82 import java.util.Map;
  83 import java.util.ArrayList;
  84 import java.util.EnumMap;
  85 import java.util.Set;
  86 import java.util.HashSet;
  87 import java.util.stream.Collectors;
  88 import java.util.stream.IntStream;
  89 import java.util.Collections;
  90 import java.util.Arrays;
  91
  92 import static org.junit.Assert.assertEquals;
  93 import static org.junit.Assert.assertSame;
  94 import static org.junit.Assert.assertTrue;
  95 import static org.mockito.Mockito.times;
  96 import static org.mockito.Mockito.verify;
  97 import static org.mockito.Mockito.when;
  98 import static org.mockito.ArgumentMatchers.any;
  99 import static org.mockito.ArgumentMatchers.anyMap;
 100 import static org.mockito.ArgumentMatchers.anyInt;
 101 import static org.mockito.ArgumentMatchers.eq;
 102
 103 @RunWith(MockitoJUnitRunner.class)
 104 public class ToscaOperationFacadeTest {
 105     private static final String COMPONENT_ID = "componentId";
 106     private static final String PROPERTY1_NAME = "prop1";
 107     private static final String PROPERTY1_TYPE = "string";
 108     private static final String PROPERTY2_NAME = "prop2";
 109     private static final String PROPERTY2_TYPE = "integer";
 110     private static final String ICON_NAME = "icon";
 111     private static final String SERVICE_MODEL_NAME = "Test_Service";
 112     private static final String SERVICE_PROXY_INSTANCE0_NAME = "testservice_proxy0";
 113     private static final String SERVICE_SUBSTITUTION_INSTANCE0_NAME = "testservice0";
 114
 115     @InjectMocks
 116     private ToscaOperationFacade testInstance;
 117
 118     @Mock
 119     private HealingJanusGraphDao janusGraphDaoMock;
 120
 121     @Mock
 122     private TopologyTemplateOperation topologyTemplateOperationMock;
 123
 124     @Mock
 125     private NodeTypeOperation nodeTypeOperation;
 126
 127     @Mock
 128     private NodeTemplateOperation nodeTemplateOperationMock;
 129
 130     @Before
 131     public void setUp() throws Exception {
 132         testInstance = new ToscaOperationFacade();
 133         MockitoAnnotations.initMocks(this);
 134     }
 135
 136     @SuppressWarnings("unchecked")
 137     @Test
 138     public void fetchMetaDataByResourceType() throws Exception {
 139         ArgumentCaptor<Map> criteriaCapture = ArgumentCaptor.forClass(Map.class);
 140         ArgumentCaptor<Map> criteriaNotCapture = ArgumentCaptor.forClass(Map.class);
 141         ComponentParametersView dataFilter = new ComponentParametersView();
 142         List<GraphVertex> mockVertices = getMockVertices(2);
 143         Either<List<GraphVertex>, JanusGraphOperationStatus> returnedVertices = Either.left(mockVertices);
 144
 145         when(janusGraphDaoMock.getByCriteria(eq(null), criteriaCapture.capture(), criteriaNotCapture.capture(), eq(JsonParseFlagEnum.ParseMetadata))).thenReturn(returnedVertices);
 146         when(topologyTemplateOperationMock.getToscaElement(mockVertices.get(0), dataFilter)).thenReturn(Either.left(getResourceToscaElement("0")));
 147         when(topologyTemplateOperationMock.getToscaElement(mockVertices.get(1), dataFilter)).thenReturn(Either.left(getResourceToscaElement("1")));
 148         Either<List<Component>, StorageOperationStatus> fetchedComponents = testInstance.fetchMetaDataByResourceType(ResourceTypeEnum.VF.getValue(), dataFilter);
 149
 150         verifyCriteriaForHighestVersionAndVfResourceType(criteriaCapture);
 151         verifyCriteriaNotIsDeleted(criteriaNotCapture);
 152
 153         assertTrue(fetchedComponents.isLeft());
 154         List<Component> cmpts = fetchedComponents.left().value();
 155         assertEquals(2, cmpts.size());
 156         assertEquals("0", cmpts.get(0).getUniqueId());
 157         assertEquals("1", cmpts.get(1).getUniqueId());
 158     }
 159
 160     private void verifyCriteriaForHighestVersionAndVfResourceType(ArgumentCaptor<Map> criteriaCapture) {
 161         Map<GraphPropertyEnum, Object> criteria = (Map<GraphPropertyEnum, Object>)criteriaCapture.getValue();
 162         assertEquals(2, criteria.size());
 163         assertEquals(criteria.get(GraphPropertyEnum.RESOURCE_TYPE), "VF");
 164         assertEquals(criteria.get(GraphPropertyEnum.IS_HIGHEST_VERSION), true);
 165     }
 166
 167     private void verifyCriteriaNotIsDeleted(ArgumentCaptor<Map> criteriaNotCapture) {
 168         Map<GraphPropertyEnum, Object> notCriteria = (Map<GraphPropertyEnum, Object>)criteriaNotCapture.getValue();
 169         assertEquals(1, notCriteria.size());
 170         assertEquals(notCriteria.get(GraphPropertyEnum.IS_DELETED), true);
 171     }
 172
 173     @SuppressWarnings("unchecked")
 174     @Test
 175     public void fetchMetaDataByResourceType_failedToGetData() throws Exception {
 176         when(janusGraphDaoMock.getByCriteria(eq(null), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseMetadata))).thenReturn(Either.right(
 177             JanusGraphOperationStatus.GENERAL_ERROR));
 178         Either<List<Component>, StorageOperationStatus> fetchedComponents = testInstance.fetchMetaDataByResourceType(ResourceTypeEnum.VF.getValue(), new ComponentParametersView());
 179         assertTrue(fetchedComponents.isRight());
 180         assertEquals(StorageOperationStatus.GENERAL_ERROR, fetchedComponents.right().value());
 181     }
 182
 183     @Test
 184     public void associatePolicyToComponentSuccessTest(){
 185         Either<PolicyDefinition, StorageOperationStatus> result = associatePolicyToComponentWithStatus(StorageOperationStatus.OK);
 186         assertTrue(result.isLeft());
 187     }
 188
 189     @Test
 190     public void associatePolicyToComponentFailureTest(){
 191         Either<PolicyDefinition, StorageOperationStatus> result = associatePolicyToComponentWithStatus(StorageOperationStatus.BAD_REQUEST);
 192         assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.BAD_REQUEST);
 193     }
 194
 195     @Test
 196     public void updatePolicyOfComponentSuccessTest(){
 197         Either<PolicyDefinition, StorageOperationStatus> result = updatePolicyOfComponentWithStatus(StorageOperationStatus.OK);
 198         assertTrue(result.isLeft());
 199     }
 200
 201     @Test
 202     public void updatePolicyOfComponentFailureTest(){
 203         Either<PolicyDefinition, StorageOperationStatus> result = updatePolicyOfComponentWithStatus(StorageOperationStatus.NOT_FOUND);
 204         assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.NOT_FOUND);
 205     }
 206
 207     @Test
 208     public void removePolicyFromComponentSuccessTest(){
 209         removePolicyFromComponentWithStatus(StorageOperationStatus.OK);
 210     }
 211
 212     @Test
 213     public void removePolicyFromComponentFailureTest(){
 214         removePolicyFromComponentWithStatus(StorageOperationStatus.NOT_FOUND);
 215     }
 216
 217     @Test
 218     public void testFindLastCertifiedToscaElementByUUID(){
 219         Either<Component, StorageOperationStatus> result;
 220         Component component = new Resource();
 221         List<GraphVertex> list = new ArrayList<>();
 222         GraphVertex graphVertex = getTopologyTemplateVertex();
 223         list.add(graphVertex);
 224         Map<GraphPropertyEnum, Object> props = new EnumMap<>(GraphPropertyEnum.class);
 225         props.put(GraphPropertyEnum.UUID, component.getUUID());
 226         props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name());
 227         props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
 228         ToscaElement toscaElement = getToscaElementForTest();
 229         when(topologyTemplateOperationMock.getToscaElement(ArgumentMatchers.eq(graphVertex),any(ComponentParametersView.class))).thenReturn(Either.left(toscaElement));
 230         when(janusGraphDaoMock.getByCriteria(ModelConverter.getVertexType(component), props)).thenReturn(Either.left(list));
 231         result = testInstance.findLastCertifiedToscaElementByUUID(component);
 232         Component resultComp = result.left().value();
 233         assertEquals(resultComp.getToscaType(),ToscaElementTypeEnum.TOPOLOGY_TEMPLATE.getValue());
 234     }
 235
 236     @Test
 237     public void testLatestComponentByToscaResourceName(){
 238         Either<Component, StorageOperationStatus> result;
 239         TopologyTemplate toscaElement = new TopologyTemplate();
 240         toscaElement.setComponentType(ComponentTypeEnum.SERVICE);
 241         List<GraphVertex> list = new ArrayList<>();
 242         GraphVertex graphVertex = getTopologyTemplateVertex();
 243         Map<GraphPropertyEnum, Object> props = new HashMap<>();
 244         props.put(GraphPropertyEnum.VERSION, "1.0");
 245         graphVertex.setMetadataProperties(props);
 246         list.add(graphVertex);
 247
 248         Map<GraphPropertyEnum, Object> propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class);
 249         Map<GraphPropertyEnum, Object> propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class);
 250         propertiesToMatch.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, "toscaResourceName");
 251         propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
 252         propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true);
 253
 254         when(janusGraphDaoMock.getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(list));
 255         when(topologyTemplateOperationMock.getToscaElement(ArgumentMatchers.eq(graphVertex),any(ComponentParametersView.class))).thenReturn(Either.left(toscaElement));
 256
 257         result = testInstance.getFullLatestComponentByToscaResourceName("toscaResourceName");
 258         assertThat(result.isLeft());
 259     }
 260
 261     @Test
 262     public void testValidateCsarUuidUniqueness() {
 263         StorageOperationStatus result;
 264         String csarUUID = "csarUUID";
 265         Map<GraphPropertyEnum, Object> properties = new EnumMap<>(GraphPropertyEnum.class);
 266         properties.put(GraphPropertyEnum.CSAR_UUID, csarUUID);
 267         List<GraphVertex> vertexList = new ArrayList<>();
 268         when(janusGraphDaoMock.getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(vertexList));
 269         result = testInstance.validateCsarUuidUniqueness(csarUUID);
 270         assertEquals(StorageOperationStatus.ENTITY_ALREADY_EXISTS, result);
 271     }
 272
 273     @Test
 274     public void testValidateCsarUuidUnique_true() {
 275         StorageOperationStatus result;
 276         String csarUUID = "csarUUID";
 277         Map<GraphPropertyEnum, Object> properties = new EnumMap<>(GraphPropertyEnum.class);
 278         properties.put(GraphPropertyEnum.CSAR_UUID, csarUUID);
 279         when(janusGraphDaoMock.getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.right(
 280             JanusGraphOperationStatus.NOT_FOUND));
 281         result = testInstance.validateCsarUuidUniqueness(csarUUID);
 282         assertEquals(StorageOperationStatus.OK, result);
 283     }
 284
 285     @Test
 286     public void testGetLatestCertiNodeTypeByToscaResourceName() {
 287         Either<Resource, StorageOperationStatus> result;
 288         String toscaResourceName = "resourceName";
 289         String uniqueId = "uniqueId";
 290         GraphVertex graphVertex = getTopologyTemplateVertex();
 291         graphVertex.setJsonMetadataField(JsonPresentationFields.VERSION, "1.0");
 292         graphVertex.setUniqueId(uniqueId);
 293         List<GraphVertex> vertexList = new ArrayList<>();
 294         vertexList.add(graphVertex);
 295         Map<GraphPropertyEnum, Object> props = new EnumMap<>(GraphPropertyEnum.class);
 296         props.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaResourceName);
 297         props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
 298         props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name());
 299         ToscaElement topologyTemplate = new TopologyTemplate();
 300         topologyTemplate.setComponentType(ComponentTypeEnum.SERVICE);
 301         when(janusGraphDaoMock.getByCriteria(VertexTypeEnum.NODE_TYPE, props, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(vertexList));
 302         when(janusGraphDaoMock.getVertexById(uniqueId, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex));
 303         when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class))).thenReturn(Either.left(topologyTemplate));
 304         result = testInstance.getLatestCertifiedNodeTypeByToscaResourceName(toscaResourceName);
 305         assertThat(result.isLeft());
 306     }
 307
 308     @Test
 309     public void testValidateCompExists() {
 310         Either<Boolean, StorageOperationStatus> result;
 311         String componentId = "componentId";
 312         GraphVertex graphVertex = getTopologyTemplateVertex();
 313         when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex));
 314         result = testInstance.validateComponentExists(componentId);
 315         assertEquals(true, result.left().value());
 316     }
 317
 318     @Test
 319     public void testValidateCompExists_NotFound() {
 320         Either<Boolean, StorageOperationStatus> result;
 321         String componentId = "componentId";
 322         when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(Either.right(
 323             JanusGraphOperationStatus.NOT_FOUND));
 324         result = testInstance.validateComponentExists(componentId);
 325         assertEquals(false, result.left().value());
 326     }
 327
 328     @Test
 329     public void testValidateToscaResourceNameExists() {
 330         Either<Boolean, StorageOperationStatus> result;
 331         String templateName = "templateName";
 332         Map<GraphPropertyEnum, Object> properties = new EnumMap<>(GraphPropertyEnum.class);
 333         properties.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, templateName);
 334         List<GraphVertex> graphVertexList = new ArrayList<>();
 335         GraphVertex graphVertex = getTopologyTemplateVertex();
 336         graphVertexList.add(graphVertex);
 337         when(janusGraphDaoMock.getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(graphVertexList));
 338         result = testInstance.validateToscaResourceNameExists(templateName);
 339         assertEquals(true, result.left().value());
 340     }
 341
 342     @Test
 343     public void testValidateToscaResourceNameExists_false() {
 344         Either<Boolean, StorageOperationStatus> result;
 345         String templateName = "templateName";
 346         Map<GraphPropertyEnum, Object> properties = new EnumMap<>(GraphPropertyEnum.class);
 347         properties.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, templateName);
 348         List<GraphVertex> graphVertexList = new ArrayList<>();
 349         GraphVertex graphVertex = getTopologyTemplateVertex();
 350         graphVertexList.add(graphVertex);
 351         when(janusGraphDaoMock.getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.right(
 352             JanusGraphOperationStatus.NOT_FOUND));
 353         result = testInstance.validateToscaResourceNameExists(templateName);
 354         assertEquals(false, result.left().value());
 355     }
 356
 357     @Test
 358     public void testOverrideComponent() {
 359         Either<Resource, StorageOperationStatus> result;
 360         Resource resource = new Resource();
 361         String id = "id";
 362         resource.setUniqueId(id);
 363         GraphVertex graphVertex = getTopologyTemplateVertex();
 364         graphVertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE);
 365         NodeType nodeType = new NodeType();
 366         nodeType.setComponentType(ComponentTypeEnum.RESOURCE);
 367         ToscaElement toscaElement = new TopologyTemplate();
 368         toscaElement.setComponentType(ComponentTypeEnum.SERVICE);
 369         when(janusGraphDaoMock.getVertexById(id, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex));
 370         when(janusGraphDaoMock.getParentVertex(graphVertex, EdgeLabelEnum.VERSION, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex));
 371         when(topologyTemplateOperationMock.deleteToscaElement(graphVertex)).thenReturn(Either.left(toscaElement));
 372         when(nodeTypeOperation.createToscaElement(any(ToscaElement.class))).thenReturn(Either.left(nodeType));
 373         when(janusGraphDaoMock.getVertexById(null, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex));
 374         when(janusGraphDaoMock.createEdge(graphVertex, graphVertex, EdgeLabelEnum.VERSION, null)).thenReturn(
 375             JanusGraphOperationStatus.OK);
 376         result = testInstance.overrideComponent(resource, resource);
 377         assertTrue(result.isLeft());
 378     }
 379
 380     @Test
 381     public void testGetToscaElement() {
 382         Either<Component, StorageOperationStatus> result;
 383         String id = "id";
 384         GraphVertex graphVertex = getTopologyTemplateVertex();
 385         ToscaElement toscaElement = getToscaElementForTest();
 386         when(janusGraphDaoMock.getVertexById(id, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex));
 387         when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class))).thenReturn(Either.left(toscaElement));
 388         result = testInstance.getToscaElement(id, JsonParseFlagEnum.ParseAll);
 389         assertTrue(result.isLeft());
 390     }
 391
 392     @Test
 393     public void testMarkComponentToDelete() {
 394         StorageOperationStatus result;
 395         Component component = new Resource();
 396         String id = "id";
 397         component.setUniqueId(id);
 398         GraphVertex graphVertex = getTopologyTemplateVertex();
 399         when(janusGraphDaoMock.getVertexById(id, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex));
 400         when(nodeTypeOperation.markComponentToDelete(graphVertex)).thenReturn(Either.left(graphVertex));
 401         result = testInstance.markComponentToDelete(component);
 402         assertEquals(result, StorageOperationStatus.OK);
 403     }
 404
 405     @Test
 406     public void testDelToscaComponent() {
 407         Either<Component, StorageOperationStatus> result;
 408         String componentId = "compId";
 409         GraphVertex graphVertex = getTopologyTemplateVertex();
 410         ToscaElement toscaElement = getToscaElementForTest();
 411         when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex));
 412         when(topologyTemplateOperationMock.deleteToscaElement(graphVertex)).thenReturn(Either.left(toscaElement));
 413         result = testInstance.deleteToscaComponent(componentId);
 414         assertTrue(result.isLeft());
 415     }
 416
 417     @Test
 418     public void testGetLatestByToscaResourceName() {
 419         Either<Component, StorageOperationStatus> result;
 420         String toscaResourceName = "name";
 421         ToscaElement toscaElement = getToscaElementForTest();
 422
 423         Map<GraphPropertyEnum, Object> propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class);
 424         propertiesToMatch.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaResourceName);
 425         propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
 426         Map<GraphPropertyEnum, Object> propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class);
 427         propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true);
 428
 429         List<GraphVertex> graphVertexList = new ArrayList<>();
 430         GraphVertex graphVertex = getTopologyTemplateVertex();
 431         graphVertex.setUniqueId(toscaResourceName);
 432         Map<GraphPropertyEnum, Object> props = new HashMap<>();
 433         props.put(GraphPropertyEnum.VERSION, "1.0");
 434         graphVertex.setMetadataProperties(props);
 435         graphVertexList.add(graphVertex);
 436
 437         when(janusGraphDaoMock.getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(graphVertexList));
 438         when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class))).thenReturn(Either.left(toscaElement));
 439         result = testInstance.getLatestByToscaResourceName(toscaResourceName);
 440         assertTrue(result.isLeft());
 441     }
 442
 443
 444     @Test
 445     public void testGetLatestResourceByToscaResourceName() {
 446         Either<Resource, StorageOperationStatus> result;
 447         String toscaResourceName = "org.openecomp.resource.vf";
 448         ToscaElement toscaElement = getToscaElementForTest();
 449
 450         Map<GraphPropertyEnum, Object> propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class);
 451         propertiesToMatch.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaResourceName);
 452         propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
 453         if (!toscaResourceName.contains("org.openecomp.resource.vf")) {
 454             propertiesToMatch.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name());
 455         }
 456
 457         List<GraphVertex> graphVertexList = new ArrayList<>();
 458         GraphVertex graphVertex = getTopologyTemplateVertex();
 459         graphVertex.setUniqueId(toscaResourceName);
 460         Map<JsonPresentationFields, Object> props = new HashMap<>();
 461         props.put(JsonPresentationFields.VERSION, "1.0");
 462         graphVertex.setJsonMetadataField(JsonPresentationFields.VERSION,  props.get(JsonPresentationFields.VERSION));
 463         graphVertexList.add(graphVertex);
 464
 465         when(janusGraphDaoMock.getByCriteria(VertexTypeEnum.TOPOLOGY_TEMPLATE, propertiesToMatch, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(graphVertexList));
 466         when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class))).thenReturn(Either.left(toscaElement));
 467
 468         when(janusGraphDaoMock.getVertexById(toscaResourceName, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex));
 469
 470         result = testInstance.getLatestResourceByToscaResourceName(toscaResourceName);
 471         assertTrue(result.isLeft());
 472     }
 473
 474     @Test
 475     public void testGetFollowed() {
 476         Either<Set<Component>, StorageOperationStatus> result;
 477         String userId = "id";
 478         Set<LifecycleStateEnum> lifecycleStates = new HashSet<>();
 479         Set<LifecycleStateEnum> lastStateStates = new HashSet<>();
 480         lifecycleStates.add(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
 481         lifecycleStates.add(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 482         lifecycleStates.add(LifecycleStateEnum.CERTIFIED);
 483         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 484         List<ToscaElement> toscaEleList = new ArrayList<>();
 485         ToscaElement toscaElement = getToscaElementForTest();
 486         toscaEleList.add(toscaElement);
 487         when(nodeTypeOperation.getFollowedComponent(userId, lifecycleStates, lastStateStates, componentType)).thenReturn(Either.left(toscaEleList));
 488         result = testInstance.getFollowed(userId, lifecycleStates, lastStateStates, componentType);
 489         assertTrue(result.isLeft());
 490         assertEquals(1, result.left().value().size());
 491     }
 492
 493     @Test
 494     public void testGetBySystemName() {
 495         Either<List<Component>, StorageOperationStatus> result;
 496         String sysName = "sysName";
 497         ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
 498         ToscaElement toscaElement = getToscaElementForTest();
 499         List<GraphVertex> componentVertices = new ArrayList<>();
 500         GraphVertex graphVertex = getTopologyTemplateVertex();
 501         componentVertices.add(graphVertex);
 502         Map<GraphPropertyEnum, Object> propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class);
 503         Map<GraphPropertyEnum, Object> propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class);
 504
 505         propertiesToMatch.put(GraphPropertyEnum.SYSTEM_NAME, sysName);
 506         propertiesToMatch.put(GraphPropertyEnum.COMPONENT_TYPE, componentTypeEnum.name());
 507
 508         propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true);
 509
 510         when(janusGraphDaoMock.getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(componentVertices));
 511         when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class))).thenReturn(Either.left(toscaElement));
 512         result = testInstance.getBySystemName(componentTypeEnum, sysName);
 513         assertTrue(result.isLeft());
 514         assertEquals(1, result.left().value().size());
 515     }
 516
 517     @Test
 518     public void testGetCompByNameAndVersion() {
 519         Either<Component, StorageOperationStatus> result;
 520         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 521         String name = "name";
 522         String version = "1.0";
 523         JsonParseFlagEnum parseFlag = JsonParseFlagEnum.ParseAll;
 524         List<GraphVertex> graphVertexList = new ArrayList<>();
 525         GraphVertex graphVertex = getTopologyTemplateVertex();
 526         graphVertexList.add(graphVertex);
 527         ToscaElement toscaElement = getToscaElementForTest();
 528         Map<GraphPropertyEnum, Object> hasProperties = new EnumMap<>(GraphPropertyEnum.class);
 529         Map<GraphPropertyEnum, Object> hasNotProperties = new EnumMap<>(GraphPropertyEnum.class);
 530
 531         hasProperties.put(GraphPropertyEnum.NAME, name);
 532         hasProperties.put(GraphPropertyEnum.VERSION, version);
 533         hasNotProperties.put(GraphPropertyEnum.IS_DELETED, true);
 534         hasProperties.put(GraphPropertyEnum.COMPONENT_TYPE, componentType.name());
 535         when(janusGraphDaoMock.getByCriteria(null, hasProperties, hasNotProperties, parseFlag)).thenReturn(Either.left(graphVertexList));
 536         when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class))).thenReturn(Either.left(toscaElement));
 537         result = testInstance.getComponentByNameAndVersion(componentType, name, version, parseFlag);
 538         assertTrue(result.isLeft());
 539     }
 540
 541     private ToscaElement getToscaElementForTest() {
 542         ToscaElement toscaElement = new TopologyTemplate();
 543         toscaElement.setComponentType(ComponentTypeEnum.RESOURCE);
 544         return toscaElement;
 545     }
 546
 547     @Test
 548     public void addDataTypesToComponentSuccessTest(){
 549         Either<List<DataTypeDefinition>, StorageOperationStatus> result = addDataTypesToComponentWithStatus(StorageOperationStatus.OK);
 550         assertTrue(result.isLeft());
 551     }
 552
 553     @Test
 554     public void addDataTypesToComponentFailureTest_BadRequest(){
 555         Either<List<DataTypeDefinition>, StorageOperationStatus> result = addDataTypesToComponentWithStatus(StorageOperationStatus.BAD_REQUEST);
 556         assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.BAD_REQUEST);
 557     }
 558
 559     private Either<List<DataTypeDefinition>, StorageOperationStatus> addDataTypesToComponentWithStatus(StorageOperationStatus status) {
 560         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 561         String componentId = "componentid";
 562         String Id = "id";
 563
 564         PropertyDefinition noDefaultProp = new PropertyDefinition();
 565         noDefaultProp.setName("noDefaultProp");
 566         PropertyDefinition prop1 = new PropertyDefinition();
 567         prop1.setDefaultValue("def1");
 568         prop1.setName("prop1");
 569         PropertyDefinition prop2 = new PropertyDefinition();
 570         prop2.setType("dataType1");
 571         prop2.setName("prop2");
 572         PropertyDefinition prop3 = new PropertyDefinition();
 573         prop3.setDefaultValue("def3");
 574         prop3.setName("prop3");
 575
 576         DataTypeDefinition noDefaultValue = new DataTypeDefinition();
 577         noDefaultValue.setProperties(Collections.singletonList(noDefaultProp));
 578         noDefaultValue.setDerivedFromName("name0");
 579
 580         DataTypeDefinition dataType1 = new DataTypeDefinition();
 581         dataType1.setProperties(Arrays.asList(prop1, prop3));
 582         dataType1.setName("name1");
 583         dataType1.setDerivedFromName("derivedfromname1");
 584
 585         DataTypeDefinition dataType2 = new DataTypeDefinition();
 586         dataType2.setDerivedFrom(dataType1);
 587         dataType2.setName("name2");
 588         dataType2.setDerivedFromName("derivedfromname2");
 589
 590         DataTypeDefinition dataType3 = new DataTypeDefinition();
 591         dataType3.setProperties(Collections.singletonList(prop2));
 592         dataType3.setDerivedFrom(noDefaultValue);
 593         dataType3.setName("name3");
 594         dataType3.setDerivedFromName("derivedfromname3");
 595
 596         dataTypes.put("noDefault", noDefaultValue);
 597         dataTypes.put("dataType1", dataType1);
 598         dataTypes.put("dataType2", dataType2);
 599         dataTypes.put("dataType3", dataType3);
 600
 601         GraphVertex vertex;
 602         if(status == StorageOperationStatus.OK){
 603             vertex = getTopologyTemplateVertex();
 604         } else {
 605             vertex = getNodeTypeVertex();
 606         }
 607         Either<GraphVertex, JanusGraphOperationStatus> getVertexEither = Either.left(vertex);
 608         when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(getVertexEither);
 609         when(topologyTemplateOperationMock.addToscaDataToToscaElement(eq(vertex),
 610                 eq(EdgeLabelEnum.DATA_TYPES), eq(VertexTypeEnum.DATA_TYPES), anyMap(), eq(JsonPresentationFields.NAME))).thenReturn(status);
 611         return testInstance.addDataTypesToComponent(dataTypes, componentId);
 612     }
 613
 614     @Test
 615     public void testDataTypesToComponentFailureTest_NotFound() {
 616         Either<List<DataTypeDefinition>, StorageOperationStatus> result;
 617         String componentId = "componentId";
 618         GraphVertex vertex = getNodeTypeVertex();
 619         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 620         when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(Either.right(
 621             JanusGraphOperationStatus.NOT_FOUND));
 622         result = testInstance.addDataTypesToComponent(dataTypes, componentId);
 623         assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.NOT_FOUND);
 624     }
 625
 626     @Test
 627     public void testDeleteDataTypeOfComponent() {
 628         StorageOperationStatus result;
 629         Component component = new Resource();
 630         String id = "id";
 631         component.setUniqueId(id);
 632         String datatype = null;
 633
 634         DataTypeDefinition dataType1 = new DataTypeDefinition();
 635         dataType1.setName("name1");
 636         Map<String, DataTypeDataDefinition> dataTypeDataMap = new HashMap<>();
 637         dataTypeDataMap.put("datatype1", dataType1);
 638         List<DataTypeDefinition> dataTypeMap = dataTypeDataMap.values().stream().map(e -> { DataTypeDefinition dataType = new DataTypeDefinition(e);return dataType; }).collect(Collectors.toList());
 639         component.setDataTypes(dataTypeMap);
 640         GraphVertex graphVertex = getTopologyTemplateVertex();
 641         result = testInstance.deleteDataTypeOfComponent(component, "datatype1");
 642         assertEquals(datatype, result);
 643     }
 644
 645     @Test
 646     public void testAddComponentInstancePropertiesToComponent() {
 647         // set up component object
 648         Component component = new Resource();
 649         component.setUniqueId(COMPONENT_ID);
 650         List<ComponentInstanceProperty> instanceProps = new ArrayList<>();
 651         ComponentInstanceProperty instanceProp = new ComponentInstanceProperty();
 652         instanceProp.setName(PROPERTY1_NAME);
 653         instanceProp.setType(PROPERTY1_TYPE);
 654         instanceProps.add(instanceProp);
 655         instanceProp = new ComponentInstanceProperty();
 656         instanceProp.setName(PROPERTY2_NAME);
 657         instanceProp.setType(PROPERTY2_TYPE);
 658         instanceProps.add(instanceProp);
 659         Map<String, List<ComponentInstanceProperty>> instancePropsMap =
 660             Collections.singletonMap(COMPONENT_ID, instanceProps);
 661         component.setComponentInstancesProperties(Collections.singletonMap(COMPONENT_ID, new ArrayList<>()));
 662
 663         when(nodeTemplateOperationMock.addComponentInstanceProperty(any(), any(), any()))
 664             .thenReturn(StorageOperationStatus.OK);
 665
 666         Either<Map<String, List<ComponentInstanceProperty>>, StorageOperationStatus> result =
 667             testInstance.addComponentInstancePropertiesToComponent(component, instancePropsMap);
 668         assertTrue(result.isLeft());
 669         verify(nodeTemplateOperationMock, times(2)).addComponentInstanceProperty(any(), any(), any());
 670         List<ComponentInstanceProperty> resultProps = result.left().value().get(COMPONENT_ID);
 671         assertTrue(resultProps.stream().anyMatch(e -> e.getName().equals(PROPERTY1_NAME)));
 672         assertTrue(resultProps.stream().anyMatch(e -> e.getName().equals(PROPERTY2_NAME)));
 673     }
 674
 675     @Test
 676     public void testAddComponentInstanceToTopologyTemplate_ServiceProxy() {
 677         Component containerComponent = new Service();
 678         Component originalComponent = new Service();
 679         ComponentInstance componentInstance = new ComponentInstance();
 680         ComponentInstance existingComponentInstance = new ComponentInstance();
 681         User user = new User();
 682
 683         containerComponent.setComponentType(ComponentTypeEnum.SERVICE);
 684
 685         originalComponent.setComponentType(ComponentTypeEnum.SERVICE);
 686         originalComponent.setIcon(ICON_NAME);
 687
 688         componentInstance.setOriginType(OriginTypeEnum.ServiceProxy);
 689         componentInstance.setSourceModelName(SERVICE_MODEL_NAME);
 690
 691         List<ComponentInstance> existingInstances = new ArrayList<>();
 692         existingComponentInstance.setNormalizedName(SERVICE_PROXY_INSTANCE0_NAME);
 693         existingInstances.add(existingComponentInstance);
 694         containerComponent.setComponentInstances(existingInstances);
 695
 696         when(nodeTemplateOperationMock
 697             .addComponentInstanceToTopologyTemplate(any(), any(), eq("1"), eq(componentInstance), eq(false), eq(user)))
 698             .thenReturn(Either.left(new ImmutablePair<>(new TopologyTemplate(), COMPONENT_ID)));
 699         TopologyTemplate topologyTemplate = new TopologyTemplate();
 700         // preset COMPONENT_TYPE field for internal ModelConverter call
 701         topologyTemplate.setMetadataValue(JsonPresentationFields.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name());
 702         when(topologyTemplateOperationMock.getToscaElement(containerComponent.getUniqueId()))
 703             .thenReturn(Either.left(topologyTemplate));
 704
 705         Either<ImmutablePair<Component, String>, StorageOperationStatus> result =
 706             testInstance.addComponentInstanceToTopologyTemplate(
 707                 containerComponent, originalComponent, componentInstance, false, user);
 708
 709         assertTrue(result.isLeft());
 710         assertEquals(componentInstance.getIcon(), ICON_NAME);
 711         assertEquals(result.left().value().getRight(), COMPONENT_ID);
 712         // the instance counter must be 1 because the service proxy instance with suffix 0 already exists.
 713         verify(nodeTemplateOperationMock, times(1))
 714             .addComponentInstanceToTopologyTemplate(any(), any(), eq("1"), eq(componentInstance), eq(false), eq(user));
 715     }
 716     @Test
 717     public void testAddComponentInstanceToTopologyTemplate_ServiceSubstitution() {
 718         Component containerComponent = new Service();
 719         Component originalComponent = new Service();
 720         ComponentInstance componentInstance = new ComponentInstance();
 721         ComponentInstance existingComponentInstance = new ComponentInstance();
 722         User user = new User();
 723
 724         containerComponent.setComponentType(ComponentTypeEnum.SERVICE);
 725
 726         originalComponent.setComponentType(ComponentTypeEnum.SERVICE);
 727         originalComponent.setIcon(ICON_NAME);
 728
 729         componentInstance.setOriginType(OriginTypeEnum.ServiceSubstitution);
 730         componentInstance.setSourceModelName(SERVICE_MODEL_NAME);
 731
 732         List<ComponentInstance> existingInstances = new ArrayList<>();
 733         existingComponentInstance.setNormalizedName(SERVICE_SUBSTITUTION_INSTANCE0_NAME);
 734         existingInstances.add(existingComponentInstance);
 735         containerComponent.setComponentInstances(existingInstances);
 736
 737         when(nodeTemplateOperationMock
 738             .addComponentInstanceToTopologyTemplate(any(), any(), eq("1"), eq(componentInstance), eq(false), eq(user)))
 739             .thenReturn(Either.left(new ImmutablePair<>(new TopologyTemplate(), COMPONENT_ID)));
 740         TopologyTemplate topologyTemplate = new TopologyTemplate();
 741         topologyTemplate.setMetadataValue(JsonPresentationFields.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name());
 742         when(topologyTemplateOperationMock.getToscaElement(containerComponent.getUniqueId()))
 743             .thenReturn(Either.left(topologyTemplate));
 744
 745         Either<ImmutablePair<Component, String>, StorageOperationStatus> result =
 746             testInstance.addComponentInstanceToTopologyTemplate(
 747                 containerComponent, originalComponent, componentInstance, false, user);
 748
 749         assertTrue(result.isLeft());
 750         assertEquals(ICON_NAME, componentInstance.getIcon());
 751         assertEquals(COMPONENT_ID, result.left().value().getRight());
 752         verify(nodeTemplateOperationMock, times(1))
 753             .addComponentInstanceToTopologyTemplate(any(), any(), eq("1"), eq(componentInstance), eq(false), eq(user));
 754     }
 755
 756     @Test
 757     public void testUpdateComponentInstanceRequirement() {
 758         String containerComponentId = "containerComponentId";
 759         String componentInstanceUniqueId= "componentInstanceUniqueId";
 760         RequirementDataDefinition requirementDataDefinition= Mockito.mock(RequirementDataDefinition.class);
 761
 762         when(nodeTemplateOperationMock.updateComponentInstanceRequirement(containerComponentId, componentInstanceUniqueId, requirementDataDefinition)).thenReturn(StorageOperationStatus.OK);
 763         StorageOperationStatus result = testInstance.updateComponentInstanceRequirement(containerComponentId, componentInstanceUniqueId, requirementDataDefinition);
 764         assertEquals(StorageOperationStatus.OK, result);
 765         verify(nodeTemplateOperationMock, times(1)).updateComponentInstanceRequirement(containerComponentId, componentInstanceUniqueId, requirementDataDefinition);
 766
 767     }
 768
 769     @Test
 770     public void associateCapabilitiesToServiceFailureTest(){
 771         StorageOperationStatus result = associateCapabilitiesToServiceWithStatus(StorageOperationStatus.BAD_REQUEST);
 772         assertTrue(result == StorageOperationStatus.BAD_REQUEST);
 773     }
 774
 775     @Test
 776     public void associateCapabilitiesToServiceSuccessTest(){
 777         StorageOperationStatus result = associateCapabilitiesToServiceWithStatus(StorageOperationStatus.OK);
 778         assertTrue(result == StorageOperationStatus.OK);
 779     }
 780
 781     private StorageOperationStatus associateCapabilitiesToServiceWithStatus(StorageOperationStatus status) {
 782         Map<String, ListCapabilityDataDefinition> capabilitiesMap = new HashedMap();
 783         String componentId = "componentid";
 784
 785         ListCapabilityDataDefinition listCapabilityDataDefinition1 = new ListCapabilityDataDefinition();
 786         capabilitiesMap.put("capabilities1", listCapabilityDataDefinition1);
 787
 788         GraphVertex vertex;
 789         if(status == StorageOperationStatus.OK){
 790             vertex = getTopologyTemplateVertex();
 791         } else {
 792             vertex = getNodeTypeVertex();
 793         }
 794
 795         Either<GraphVertex, JanusGraphOperationStatus> getVertexEither = Either.left(vertex);
 796         when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(getVertexEither);
 797         when(topologyTemplateOperationMock.associateElementToData(eq(vertex),
 798             eq(VertexTypeEnum.CAPABILITIES), eq(EdgeLabelEnum.CAPABILITIES), anyMap())).thenReturn(Either.right(status));
 799         return testInstance.associateCapabilitiesToService(capabilitiesMap, componentId);
 800     }
 801
 802     @Test
 803     public void associateRequirementsToServiceFailureTest(){
 804         StorageOperationStatus result = associateRequirementsToServiceWithStatus(StorageOperationStatus.BAD_REQUEST);
 805         assertTrue(result == StorageOperationStatus.BAD_REQUEST);
 806     }
 807
 808     @Test
 809     public void associateRequirementsToServiceSuccessTest(){
 810         StorageOperationStatus result = associateRequirementsToServiceWithStatus(StorageOperationStatus.OK);
 811         assertTrue(result == StorageOperationStatus.OK);
 812     }
 813
 814     private StorageOperationStatus associateRequirementsToServiceWithStatus(StorageOperationStatus status) {
 815         Map<String, ListRequirementDataDefinition> requirementsMap = new HashedMap();
 816         String componentId = "componentid";
 817
 818         ListRequirementDataDefinition listRequirementDataDefinition1 = new ListRequirementDataDefinition();
 819         requirementsMap.put("requirements1", listRequirementDataDefinition1);
 820
 821         GraphVertex vertex;
 822         if(status == StorageOperationStatus.OK){
 823             vertex = getTopologyTemplateVertex();
 824         } else {
 825             vertex = getNodeTypeVertex();
 826         }
 827
 828         Either<GraphVertex, JanusGraphOperationStatus> getVertexEither = Either.left(vertex);
 829         when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(getVertexEither);
 830         when(topologyTemplateOperationMock.associateElementToData(eq(vertex),
 831             eq(VertexTypeEnum.REQUIREMENTS), eq(EdgeLabelEnum.REQUIREMENTS), anyMap())).thenReturn(Either.right(status));
 832         return testInstance.associateRequirementsToService(requirementsMap, componentId);
 833     }
 834
 835     private Either<PolicyDefinition, StorageOperationStatus> associatePolicyToComponentWithStatus(StorageOperationStatus status) {
 836         PolicyDefinition policy = new PolicyDefinition();
 837         String componentId = "componentId";
 838         int counter = 0;
 839         GraphVertex vertex;
 840         if(status == StorageOperationStatus.OK){
 841             vertex = getTopologyTemplateVertex();
 842         } else {
 843             vertex = getNodeTypeVertex();
 844         }
 845         Either<GraphVertex, JanusGraphOperationStatus> getVertexEither = Either.left(vertex);
 846         when(janusGraphDaoMock.getVertexById(eq(componentId), eq(JsonParseFlagEnum.ParseMetadata))).thenReturn(getVertexEither);
 847         when(topologyTemplateOperationMock.addPolicyToToscaElement(eq(vertex), any(PolicyDefinition.class), anyInt())).thenReturn(status);
 848         return testInstance.associatePolicyToComponent(componentId, policy, counter);
 849     }
 850
 851     private Either<PolicyDefinition, StorageOperationStatus> updatePolicyOfComponentWithStatus(StorageOperationStatus status) {
 852         PolicyDefinition policy = new PolicyDefinition();
 853         String componentId = "componentId";
 854         GraphVertex vertex = getTopologyTemplateVertex();
 855         when(janusGraphDaoMock.getVertexById(eq(componentId), eq(JsonParseFlagEnum.NoParse))).thenReturn(Either.left(vertex));
 856         when(topologyTemplateOperationMock.updatePolicyOfToscaElement(eq(vertex), any(PolicyDefinition.class))).thenReturn(status);
 857         return testInstance.updatePolicyOfComponent(componentId, policy, PromoteVersionEnum.NONE);
 858     }
 859
 860     private void removePolicyFromComponentWithStatus(StorageOperationStatus status) {
 861         String componentId = "componentId";
 862         String policyId = "policyId";
 863         GraphVertex vertex = getTopologyTemplateVertex();
 864         Either<GraphVertex, JanusGraphOperationStatus> getVertexEither = Either.left(vertex);
 865         when(janusGraphDaoMock.getVertexById(eq(componentId), eq(JsonParseFlagEnum.NoParse))).thenReturn(getVertexEither);
 866         when(topologyTemplateOperationMock.removePolicyFromToscaElement(eq(vertex), eq(policyId))).thenReturn(status);
 867         StorageOperationStatus result = testInstance.removePolicyFromComponent(componentId, policyId);
 868         assertSame(result, status);
 869     }
 870
 871     private List<GraphVertex> getMockVertices(int numOfVertices) {
 872         return IntStream.range(0, numOfVertices).mapToObj(i -> getTopologyTemplateVertex()).collect(Collectors.toList());
 873     }
 874
 875     private ToscaElement getResourceToscaElement(String id) {
 876         ToscaElement toscaElement = new TopologyTemplate();
 877         toscaElement.setMetadata(new HashMap<>());
 878         toscaElement.getMetadata().put(JsonPresentationFields.COMPONENT_TYPE.getPresentation(), "RESOURCE");
 879         toscaElement.getMetadata().put(JsonPresentationFields.UNIQUE_ID.getPresentation(), id);
 880         return toscaElement;
 881     }
 882
 883     private GraphVertex getTopologyTemplateVertex() {
 884         GraphVertex graphVertex = new GraphVertex();
 885         graphVertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE);
 886         return graphVertex;
 887     }
 888
 889     private GraphVertex getNodeTypeVertex() {
 890         GraphVertex graphVertex = new GraphVertex();
 891         graphVertex.setLabel(VertexTypeEnum.NODE_TYPE);
 892         return graphVertex;
 893     }
 894 }