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 static org.assertj.core.api.Assertions.assertThat;
  33 import static org.junit.Assert.assertEquals;
  34 import static org.junit.Assert.assertFalse;
  35 import static org.junit.Assert.assertNotNull;
  36 import static org.junit.Assert.assertNull;
  37 import static org.junit.Assert.assertSame;
  38 import static org.junit.Assert.assertTrue;
  39 import static org.junit.jupiter.api.Assertions.assertThrows;
  40 import static org.mockito.ArgumentMatchers.any;
  41 import static org.mockito.ArgumentMatchers.anyInt;
  42 import static org.mockito.ArgumentMatchers.anyMap;
  43 import static org.mockito.ArgumentMatchers.anyString;
  44 import static org.mockito.ArgumentMatchers.eq;
  45 import static org.mockito.Mockito.doReturn;
  46 import static org.mockito.Mockito.times;
  47 import static org.mockito.Mockito.verify;
  48 import static org.mockito.Mockito.when;
  49
  50 import fj.data.Either;
  51 import java.util.ArrayList;
  52 import java.util.Arrays;
  53 import java.util.Collections;
  54 import java.util.EnumMap;
  55 import java.util.HashMap;
  56 import java.util.HashSet;
  57 import java.util.List;
  58 import java.util.Map;
  59 import java.util.Set;
  60 import java.util.stream.Collectors;
  61 import java.util.stream.IntStream;
  62 import org.apache.commons.collections.map.HashedMap;
  63 import org.apache.commons.lang3.tuple.ImmutablePair;
  64 import org.junit.Before;
  65 import org.junit.Test;
  66 import org.junit.runner.RunWith;
  67 import org.mockito.ArgumentCaptor;
  68 import org.mockito.ArgumentMatchers;
  69 import org.mockito.InjectMocks;
  70 import org.mockito.Mock;
  71 import org.mockito.Mockito;
  72 import org.mockito.MockitoAnnotations;
  73 import org.mockito.junit.MockitoJUnitRunner;
  74 import org.openecomp.sdc.be.config.ComponentType;
  75 import org.openecomp.sdc.be.dao.api.ActionStatus;
  76 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  77 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  78 import org.openecomp.sdc.be.dao.janusgraph.HealingJanusGraphDao;
  79 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  80 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  81 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  82 import org.openecomp.sdc.be.datatypes.elements.AttributeDataDefinition;
  83 import org.openecomp.sdc.be.datatypes.elements.DataTypeDataDefinition;
  84 import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
  85 import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition;
  86 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
  87 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  88 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
  89 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  90 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  91 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
  92 import org.openecomp.sdc.be.datatypes.enums.PromoteVersionEnum;
  93 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  94 import org.openecomp.sdc.be.model.AttributeDefinition;
  95 import org.openecomp.sdc.be.model.Component;
  96 import org.openecomp.sdc.be.model.ComponentInstance;
  97 import org.openecomp.sdc.be.model.ComponentInstanceAttribute;
  98 import org.openecomp.sdc.be.model.ComponentInstanceOutput;
  99 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
 100 import org.openecomp.sdc.be.model.ComponentParametersView;
 101 import org.openecomp.sdc.be.model.DataTypeDefinition;
 102 import org.openecomp.sdc.be.model.LifecycleStateEnum;
 103 import org.openecomp.sdc.be.model.OutputDefinition;
 104 import org.openecomp.sdc.be.model.PolicyDefinition;
 105 import org.openecomp.sdc.be.model.PropertyDefinition;
 106 import org.openecomp.sdc.be.model.Resource;
 107 import org.openecomp.sdc.be.model.Service;
 108 import org.openecomp.sdc.be.model.User;
 109 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.NodeType;
 110 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate;
 111 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement;
 112 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElementTypeEnum;
 113 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.OperationException;
 114 import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter;
 115 import org.openecomp.sdc.be.model.operations.StorageException;
 116 import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
 117 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
 118
 119 @RunWith(MockitoJUnitRunner.class)
 120 public class ToscaOperationFacadeTest {
 121
 122     private static final String COMPONENT_ID = "componentId";
 123     private static final String PROPERTY1_NAME = "prop1";
 124     private static final String PROPERTY1_TYPE = "string";
 125     private static final String PROPERTY2_NAME = "prop2";
 126     private static final String PROPERTY2_TYPE = "integer";
 127     private static final String ICON_NAME = "icon";
 128     private static final String SERVICE_MODEL_NAME = "Test_Service";
 129     private static final String SERVICE_PROXY_INSTANCE0_NAME = "testservice_proxy0";
 130     private static final String SERVICE_SUBSTITUTION_INSTANCE0_NAME = "testservice0";
 131
 132     @InjectMocks
 133     private ToscaOperationFacade testInstance;
 134
 135     @Mock
 136     private HealingJanusGraphDao janusGraphDaoMock;
 137
 138     @Mock
 139     private TopologyTemplateOperation topologyTemplateOperationMock;
 140
 141     @Mock
 142     private NodeTypeOperation nodeTypeOperationMock;
 143
 144     @Mock
 145     private NodeTemplateOperation nodeTemplateOperationMock;
 146
 147     @Mock
 148     private IGraphLockOperation graphLockOperationMock;
 149
 150     @Before
 151     public void setUp() throws Exception {
 152         testInstance = new ToscaOperationFacade();
 153         MockitoAnnotations.openMocks(this);
 154     }
 155
 156     @SuppressWarnings("unchecked")
 157     @Test
 158     public void fetchMetaDataByResourceType() throws Exception {
 159         ArgumentCaptor<Map> criteriaCapture = ArgumentCaptor.forClass(Map.class);
 160         ArgumentCaptor<Map> criteriaNotCapture = ArgumentCaptor.forClass(Map.class);
 161         ComponentParametersView dataFilter = new ComponentParametersView();
 162         List<GraphVertex> mockVertices = getMockVertices(2);
 163         Either<List<GraphVertex>, JanusGraphOperationStatus> returnedVertices = Either.left(mockVertices);
 164
 165         when(janusGraphDaoMock.getByCriteria(eq(null), criteriaCapture.capture(), criteriaNotCapture.capture(), eq(JsonParseFlagEnum.ParseMetadata)))
 166             .thenReturn(returnedVertices);
 167         when(topologyTemplateOperationMock.getToscaElement(mockVertices.get(0), dataFilter)).thenReturn(Either.left(getResourceToscaElement("0")));
 168         when(topologyTemplateOperationMock.getToscaElement(mockVertices.get(1), dataFilter)).thenReturn(Either.left(getResourceToscaElement("1")));
 169         Either<List<Component>, StorageOperationStatus> fetchedComponents = testInstance
 170             .fetchMetaDataByResourceType(ResourceTypeEnum.VF.getValue(), dataFilter);
 171
 172         verifyCriteriaForHighestVersionAndVfResourceType(criteriaCapture);
 173         verifyCriteriaNotIsDeleted(criteriaNotCapture);
 174
 175         assertTrue(fetchedComponents.isLeft());
 176         List<Component> cmpts = fetchedComponents.left().value();
 177         assertEquals(2, cmpts.size());
 178         assertEquals("0", cmpts.get(0).getUniqueId());
 179         assertEquals("1", cmpts.get(1).getUniqueId());
 180     }
 181
 182     private void verifyCriteriaForHighestVersionAndVfResourceType(ArgumentCaptor<Map> criteriaCapture) {
 183         Map<GraphPropertyEnum, Object> criteria = (Map<GraphPropertyEnum, Object>) criteriaCapture.getValue();
 184         assertEquals(2, criteria.size());
 185         assertEquals("VF", criteria.get(GraphPropertyEnum.RESOURCE_TYPE));
 186         assertEquals(true, criteria.get(GraphPropertyEnum.IS_HIGHEST_VERSION));
 187     }
 188
 189     private void verifyCriteriaNotIsDeleted(ArgumentCaptor<Map> criteriaNotCapture) {
 190         Map<GraphPropertyEnum, Object> notCriteria = (Map<GraphPropertyEnum, Object>) criteriaNotCapture.getValue();
 191         assertEquals(1, notCriteria.size());
 192         assertEquals(true, notCriteria.get(GraphPropertyEnum.IS_DELETED));
 193     }
 194
 195     @SuppressWarnings("unchecked")
 196     @Test
 197     public void fetchMetaDataByResourceType_failedToGetData() throws Exception {
 198         when(janusGraphDaoMock.getByCriteria(eq(null), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseMetadata))).thenReturn(Either.right(
 199             JanusGraphOperationStatus.GENERAL_ERROR));
 200         Either<List<Component>, StorageOperationStatus> fetchedComponents = testInstance
 201             .fetchMetaDataByResourceType(ResourceTypeEnum.VF.getValue(), new ComponentParametersView());
 202         assertTrue(fetchedComponents.isRight());
 203         assertEquals(StorageOperationStatus.GENERAL_ERROR, fetchedComponents.right().value());
 204     }
 205
 206     @Test
 207     public void associatePolicyToComponentSuccessTest() {
 208         Either<PolicyDefinition, StorageOperationStatus> result = associatePolicyToComponentWithStatus(StorageOperationStatus.OK);
 209         assertTrue(result.isLeft());
 210     }
 211
 212     @Test
 213     public void associatePolicyToComponentFailureTest() {
 214         Either<PolicyDefinition, StorageOperationStatus> result = associatePolicyToComponentWithStatus(StorageOperationStatus.BAD_REQUEST);
 215         assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.BAD_REQUEST);
 216     }
 217
 218     @Test
 219     public void updatePolicyOfComponentSuccessTest() {
 220         Either<PolicyDefinition, StorageOperationStatus> result = updatePolicyOfComponentWithStatus(StorageOperationStatus.OK);
 221         assertTrue(result.isLeft());
 222     }
 223
 224     @Test
 225     public void updatePolicyOfComponentFailureTest() {
 226         Either<PolicyDefinition, StorageOperationStatus> result = updatePolicyOfComponentWithStatus(StorageOperationStatus.NOT_FOUND);
 227         assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.NOT_FOUND);
 228     }
 229
 230     @Test
 231     public void removePolicyFromComponentSuccessTest() {
 232         removePolicyFromComponentWithStatus(StorageOperationStatus.OK);
 233     }
 234
 235     @Test
 236     public void removePolicyFromComponentFailureTest() {
 237         removePolicyFromComponentWithStatus(StorageOperationStatus.NOT_FOUND);
 238     }
 239
 240     @Test
 241     public void testFindLastCertifiedToscaElementByUUID() {
 242         Either<Component, StorageOperationStatus> result;
 243         Component component = new Resource();
 244         List<GraphVertex> list = new ArrayList<>();
 245         GraphVertex graphVertex = getTopologyTemplateVertex();
 246         list.add(graphVertex);
 247         Map<GraphPropertyEnum, Object> props = new EnumMap<>(GraphPropertyEnum.class);
 248         props.put(GraphPropertyEnum.UUID, component.getUUID());
 249         props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name());
 250         props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
 251         ToscaElement toscaElement = getToscaElementForTest();
 252         when(topologyTemplateOperationMock.getToscaElement(ArgumentMatchers.eq(graphVertex), any(ComponentParametersView.class)))
 253             .thenReturn(Either.left(toscaElement));
 254         when(janusGraphDaoMock.getByCriteria(ModelConverter.getVertexType(component), props)).thenReturn(Either.left(list));
 255         result = testInstance.findLastCertifiedToscaElementByUUID(component);
 256         Component resultComp = result.left().value();
 257         assertEquals(resultComp.getToscaType(), ToscaElementTypeEnum.TOPOLOGY_TEMPLATE.getValue());
 258     }
 259
 260     @Test
 261     public void testLatestComponentByToscaResourceName() {
 262         Either<Component, StorageOperationStatus> result;
 263         TopologyTemplate toscaElement = new TopologyTemplate();
 264         toscaElement.setComponentType(ComponentTypeEnum.SERVICE);
 265         List<GraphVertex> list = new ArrayList<>();
 266         GraphVertex graphVertex = getTopologyTemplateVertex();
 267         Map<GraphPropertyEnum, Object> props = new HashMap<>();
 268         props.put(GraphPropertyEnum.VERSION, "1.0");
 269         graphVertex.setMetadataProperties(props);
 270         list.add(graphVertex);
 271
 272         Map<GraphPropertyEnum, Object> propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class);
 273         Map<GraphPropertyEnum, Object> propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class);
 274         propertiesToMatch.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, "toscaResourceName");
 275         propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
 276         propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true);
 277
 278         when(janusGraphDaoMock.getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll, null))
 279             .thenReturn(Either.left(list));
 280         when(topologyTemplateOperationMock.getToscaElement(ArgumentMatchers.eq(graphVertex), any(ComponentParametersView.class)))
 281             .thenReturn(Either.left(toscaElement));
 282
 283         result = testInstance.getFullLatestComponentByToscaResourceName("toscaResourceName");
 284         assertTrue(result.isLeft());
 285     }
 286
 287     @Test
 288     public void testValidateCsarUuidUniqueness() {
 289         StorageOperationStatus result;
 290         String csarUUID = "csarUUID";
 291         Map<GraphPropertyEnum, Object> properties = new EnumMap<>(GraphPropertyEnum.class);
 292         properties.put(GraphPropertyEnum.CSAR_UUID, csarUUID);
 293         List<GraphVertex> vertexList = new ArrayList<>();
 294         when(janusGraphDaoMock.getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(vertexList));
 295         result = testInstance.validateCsarUuidUniqueness(csarUUID);
 296         assertEquals(StorageOperationStatus.ENTITY_ALREADY_EXISTS, result);
 297     }
 298
 299     @Test
 300     public void testValidateCsarUuidUnique_true() {
 301         StorageOperationStatus result;
 302         String csarUUID = "csarUUID";
 303         Map<GraphPropertyEnum, Object> properties = new EnumMap<>(GraphPropertyEnum.class);
 304         properties.put(GraphPropertyEnum.CSAR_UUID, csarUUID);
 305         when(janusGraphDaoMock.getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.right(
 306             JanusGraphOperationStatus.NOT_FOUND));
 307         result = testInstance.validateCsarUuidUniqueness(csarUUID);
 308         assertEquals(StorageOperationStatus.OK, result);
 309     }
 310
 311     @Test
 312     public void testGetLatestCertiNodeTypeByToscaResourceName() {
 313         Either<Resource, StorageOperationStatus> result;
 314         String toscaResourceName = "resourceName";
 315         String uniqueId = "uniqueId";
 316         GraphVertex graphVertex = getTopologyTemplateVertex();
 317         graphVertex.setJsonMetadataField(JsonPresentationFields.VERSION, "1.0");
 318         graphVertex.setUniqueId(uniqueId);
 319         List<GraphVertex> vertexList = new ArrayList<>();
 320         vertexList.add(graphVertex);
 321         Map<GraphPropertyEnum, Object> props = new EnumMap<>(GraphPropertyEnum.class);
 322         props.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaResourceName);
 323         props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
 324         props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name());
 325         ToscaElement topologyTemplate = new TopologyTemplate();
 326         topologyTemplate.setComponentType(ComponentTypeEnum.SERVICE);
 327         when(janusGraphDaoMock.getByCriteria(VertexTypeEnum.NODE_TYPE, props, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(vertexList));
 328         when(janusGraphDaoMock.getVertexById(uniqueId, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex));
 329         when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class)))
 330             .thenReturn(Either.left(topologyTemplate));
 331         result = testInstance.getLatestCertifiedNodeTypeByToscaResourceName(toscaResourceName);
 332         assertTrue(result.isLeft());
 333     }
 334
 335     @Test
 336     public void testValidateCompExists() {
 337         Either<Boolean, StorageOperationStatus> result;
 338         String componentId = "componentId";
 339         GraphVertex graphVertex = getTopologyTemplateVertex();
 340         when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex));
 341         result = testInstance.validateComponentExists(componentId);
 342         assertEquals(true, result.left().value());
 343     }
 344
 345     @Test
 346     public void testValidateCompExists_NotFound() {
 347         Either<Boolean, StorageOperationStatus> result;
 348         String componentId = "componentId";
 349         when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(Either.right(
 350             JanusGraphOperationStatus.NOT_FOUND));
 351         result = testInstance.validateComponentExists(componentId);
 352         assertEquals(false, result.left().value());
 353     }
 354
 355     @Test
 356     public void testValidateToscaResourceNameExists() {
 357         Either<Boolean, StorageOperationStatus> result;
 358         String templateName = "templateName";
 359         Map<GraphPropertyEnum, Object> properties = new EnumMap<>(GraphPropertyEnum.class);
 360         properties.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, templateName);
 361         List<GraphVertex> graphVertexList = new ArrayList<>();
 362         GraphVertex graphVertex = getTopologyTemplateVertex();
 363         graphVertexList.add(graphVertex);
 364         when(janusGraphDaoMock.getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(graphVertexList));
 365         result = testInstance.validateToscaResourceNameExists(templateName);
 366         assertEquals(true, result.left().value());
 367     }
 368
 369     @Test
 370     public void testValidateToscaResourceNameExists_false() {
 371         Either<Boolean, StorageOperationStatus> result;
 372         String templateName = "templateName";
 373         Map<GraphPropertyEnum, Object> properties = new EnumMap<>(GraphPropertyEnum.class);
 374         properties.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, templateName);
 375         List<GraphVertex> graphVertexList = new ArrayList<>();
 376         GraphVertex graphVertex = getTopologyTemplateVertex();
 377         graphVertexList.add(graphVertex);
 378         when(janusGraphDaoMock.getByCriteria(null, properties, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.right(
 379             JanusGraphOperationStatus.NOT_FOUND));
 380         result = testInstance.validateToscaResourceNameExists(templateName);
 381         assertEquals(false, result.left().value());
 382     }
 383
 384     @Test
 385     public void testOverrideComponent() {
 386         Either<Resource, StorageOperationStatus> result;
 387         Resource resource = new Resource();
 388         String id = "id";
 389         resource.setUniqueId(id);
 390         GraphVertex graphVertex = getTopologyTemplateVertex();
 391         graphVertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE);
 392         NodeType nodeType = new NodeType();
 393         nodeType.setComponentType(ComponentTypeEnum.RESOURCE);
 394         ToscaElement toscaElement = new TopologyTemplate();
 395         toscaElement.setComponentType(ComponentTypeEnum.SERVICE);
 396         when(janusGraphDaoMock.getVertexById(id, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex));
 397         when(janusGraphDaoMock.getParentVertex(graphVertex, EdgeLabelEnum.VERSION, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex));
 398         when(topologyTemplateOperationMock.deleteToscaElement(graphVertex)).thenReturn(Either.left(toscaElement));
 399         when(nodeTypeOperationMock.createToscaElement(any(ToscaElement.class))).thenReturn(Either.left(nodeType));
 400         when(janusGraphDaoMock.getVertexById(null, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(graphVertex));
 401         when(janusGraphDaoMock.createEdge(graphVertex, graphVertex, EdgeLabelEnum.VERSION, null)).thenReturn(
 402             JanusGraphOperationStatus.OK);
 403         result = testInstance.overrideComponent(resource, resource);
 404         assertTrue(result.isLeft());
 405     }
 406
 407     @Test
 408     public void testGetToscaElement() {
 409         Either<Component, StorageOperationStatus> result;
 410         String id = "id";
 411         GraphVertex graphVertex = getTopologyTemplateVertex();
 412         ToscaElement toscaElement = getToscaElementForTest();
 413         when(janusGraphDaoMock.getVertexById(id, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex));
 414         when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class)))
 415             .thenReturn(Either.left(toscaElement));
 416         result = testInstance.getToscaElement(id, JsonParseFlagEnum.ParseAll);
 417         assertTrue(result.isLeft());
 418     }
 419
 420     @Test
 421     public void testDeleteService_ServiceInUse() {
 422         String invariantUUID = "12345";
 423         String serviceUid = "1";
 424         GraphVertex service1 = getTopologyTemplateVertex();
 425         service1.setUniqueId(serviceUid);
 426         List<GraphVertex> allResourcesToDelete = new ArrayList<>();
 427         allResourcesToDelete.add(service1);
 428         Map<GraphPropertyEnum, Object> propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class);
 429         propertiesToMatch.put(GraphPropertyEnum.INVARIANT_UUID, invariantUUID);
 430         ToscaElement toscaElement = getToscaElementForTest();
 431         toscaElement.setUniqueId(serviceUid);
 432         String service2Name = "service2Name";
 433         Map<String, Object> service2MetadataJson = new HashMap<>();
 434         service2MetadataJson.put(GraphPropertyEnum.COMPONENT_TYPE.getProperty(), ComponentType.SERVICE);
 435         service2MetadataJson.put(GraphPropertyEnum.NAME.getProperty(), service2Name);
 436         String service2Uid = "2";
 437         GraphVertex usingService = getTopologyTemplateVertex();
 438         usingService.setUniqueId(service2Uid);
 439         usingService.setMetadataJson(service2MetadataJson);
 440         List<GraphVertex> inUseBy = new ArrayList<>();
 441         inUseBy.add(usingService);
 442
 443         when(janusGraphDaoMock.getByCriteria(null, propertiesToMatch, JsonParseFlagEnum.ParseMetadata)).
 444                 thenReturn(Either.left(allResourcesToDelete));
 445         doReturn(Either.left(toscaElement)).when(topologyTemplateOperationMock).getToscaElement(eq(service1), any(ComponentParametersView.class));
 446         when(topologyTemplateOperationMock.
 447                 getComponentByLabelAndId(serviceUid, ToscaElementTypeEnum.TOPOLOGY_TEMPLATE, JsonParseFlagEnum.ParseAll)).
 448                 thenReturn(Either.left(service1));
 449         when(janusGraphDaoMock.getParentVertices(any(GraphVertex.class), any(), eq(JsonParseFlagEnum.ParseAll))).
 450                 thenReturn(Either.left(inUseBy)).thenReturn(Either.left(inUseBy));
 451         final OperationException actualException = assertThrows(OperationException.class, () -> testInstance.deleteService(invariantUUID, true));
 452         assertEquals(actualException.getActionStatus(), ActionStatus.COMPONENT_IN_USE_BY_ANOTHER_COMPONENT);
 453         assertEquals(actualException.getParams()[0], ComponentType.SERVICE +  " " + service2Name);
 454     }
 455
 456     @Test
 457     public void testDeleteService_WithOneVersion() {
 458         String invariantUUID = "12345";
 459         String serviceUid = "1";
 460         Map<GraphPropertyEnum, Object> propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class);
 461         propertiesToMatch.put(GraphPropertyEnum.INVARIANT_UUID, invariantUUID);
 462         GraphVertex service1 = getTopologyTemplateVertex();
 463         service1.setUniqueId(serviceUid);
 464         List<GraphVertex> allResourcesToDelete = new ArrayList<>();
 465         allResourcesToDelete.add(service1);
 466         ToscaElement toscaElement = getToscaElementForTest();
 467         toscaElement.setUniqueId(serviceUid);
 468         List<String> affectedComponentIds = new ArrayList<>();
 469         affectedComponentIds.add(service1.getUniqueId());
 470
 471         when(janusGraphDaoMock.getByCriteria(null, propertiesToMatch, JsonParseFlagEnum.ParseMetadata)).
 472                 thenReturn(Either.left(allResourcesToDelete));
 473         doReturn(Either.left(toscaElement)).when(topologyTemplateOperationMock).getToscaElement(eq(service1), any(ComponentParametersView.class));
 474         when(topologyTemplateOperationMock.
 475                 getComponentByLabelAndId(serviceUid, ToscaElementTypeEnum.TOPOLOGY_TEMPLATE, JsonParseFlagEnum.ParseAll)).
 476                 thenReturn(Either.left(service1));
 477         when(janusGraphDaoMock.getParentVertices(eq(service1), any(), eq(JsonParseFlagEnum.ParseAll))).
 478                 thenReturn(Either.right(JanusGraphOperationStatus.OK));
 479         when(graphLockOperationMock.lockComponent(service1.getUniqueId(), NodeTypeEnum.Service)).
 480                 thenReturn(StorageOperationStatus.OK);
 481         when(topologyTemplateOperationMock.deleteToscaElement(service1)).thenReturn(Either.left(toscaElement));
 482         assertEquals(affectedComponentIds, testInstance.deleteService(invariantUUID, true));
 483     }
 484
 485     @Test
 486     public void testDeleteService_WithTwoVersions() {
 487         String invariantUUID = "12345";
 488         String serviceUid = "1";
 489         String service2Uid = "2";
 490         GraphVertex service = getTopologyTemplateVertex();
 491         service.setUniqueId(serviceUid);
 492         GraphVertex serviceV2 = getTopologyTemplateVertex();
 493         serviceV2.setUniqueId(service2Uid);
 494         ToscaElement toscaElement = getToscaElementForTest();
 495         toscaElement.setUniqueId(serviceUid);
 496         ToscaElement toscaElement2 = getToscaElementForTest();
 497         toscaElement2.setUniqueId(service2Uid);
 498         List<String> affectedComponentIds = new ArrayList<>();
 499         affectedComponentIds.add(service.getUniqueId());
 500         affectedComponentIds.add(serviceV2.getUniqueId());
 501         List<GraphVertex> allResourcesToDelete = new ArrayList<>();
 502         allResourcesToDelete.add(service);
 503         allResourcesToDelete.add(serviceV2);
 504         Map<GraphPropertyEnum, Object> propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class);
 505         propertiesToMatch.put(GraphPropertyEnum.INVARIANT_UUID, invariantUUID);
 506
 507         when(janusGraphDaoMock.getByCriteria(null, propertiesToMatch, JsonParseFlagEnum.ParseMetadata)).
 508                 thenReturn(Either.left(allResourcesToDelete));
 509         doReturn(Either.left(toscaElement)).when(topologyTemplateOperationMock).
 510                 getToscaElement(eq(service), any(ComponentParametersView.class));
 511         doReturn(Either.left(toscaElement2)).when(topologyTemplateOperationMock).
 512                 getToscaElement(eq(serviceV2), any(ComponentParametersView.class));
 513         when(topologyTemplateOperationMock.
 514                 getComponentByLabelAndId(serviceUid, ToscaElementTypeEnum.TOPOLOGY_TEMPLATE, JsonParseFlagEnum.ParseAll)).
 515                 thenReturn(Either.left(service));
 516         when(topologyTemplateOperationMock.
 517                 getComponentByLabelAndId(service2Uid, ToscaElementTypeEnum.TOPOLOGY_TEMPLATE, JsonParseFlagEnum.ParseAll)).
 518                 thenReturn(Either.left(serviceV2));
 519         when(janusGraphDaoMock.getParentVertices(any(GraphVertex.class), any(), eq(JsonParseFlagEnum.ParseAll))).
 520                 thenReturn(Either.right(JanusGraphOperationStatus.OK));
 521         when(graphLockOperationMock.lockComponent(service.getUniqueId(), NodeTypeEnum.Service)).
 522             thenReturn(StorageOperationStatus.OK);
 523         when(graphLockOperationMock.lockComponent(serviceV2.getUniqueId(), NodeTypeEnum.Service)).
 524                 thenReturn(StorageOperationStatus.OK);
 525         when(topologyTemplateOperationMock.deleteToscaElement(service)).thenReturn(Either.left(toscaElement));
 526         when(topologyTemplateOperationMock.deleteToscaElement(serviceV2)).thenReturn(Either.left(toscaElement));
 527         assertEquals(affectedComponentIds, testInstance.deleteService(invariantUUID, true));
 528     }
 529
 530     @Test
 531     public void testDeleteService_FailDelete() {
 532         String invariantUUID = "12345";
 533         String serviceUid = "1";
 534         GraphVertex service = getTopologyTemplateVertex();
 535         service.setUniqueId(serviceUid);
 536         ToscaElement toscaElement = getToscaElementForTest();
 537         toscaElement.setUniqueId(serviceUid);
 538         List<GraphVertex> allResourcesToDelete = new ArrayList<>();
 539         allResourcesToDelete.add(service);
 540         Map<GraphPropertyEnum, Object> propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class);
 541         propertiesToMatch.put(GraphPropertyEnum.INVARIANT_UUID, invariantUUID);
 542
 543         when(janusGraphDaoMock.getByCriteria(null, propertiesToMatch, JsonParseFlagEnum.ParseMetadata)).
 544                 thenReturn(Either.left(allResourcesToDelete));
 545         doReturn(Either.left(toscaElement)).when(topologyTemplateOperationMock).getToscaElement(eq(service), any(ComponentParametersView.class));
 546         when(topologyTemplateOperationMock.getComponentByLabelAndId(serviceUid, ToscaElementTypeEnum.TOPOLOGY_TEMPLATE, JsonParseFlagEnum.ParseAll)).
 547                 thenReturn(Either.left(service));
 548         when(janusGraphDaoMock.getParentVertices(eq(service), any(), eq(JsonParseFlagEnum.ParseAll))).
 549                 thenReturn(Either.right(JanusGraphOperationStatus.OK));
 550         when(graphLockOperationMock.lockComponent(service.getUniqueId(), NodeTypeEnum.Service)).
 551                 thenReturn(StorageOperationStatus.OK);
 552         when(topologyTemplateOperationMock.deleteToscaElement(service))
 553                 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 554         assertThrows(StorageException.class, () -> testInstance.deleteService(invariantUUID, true));
 555     }
 556
 557     @Test
 558     public void testDeleteService_NotFound() {
 559         String invariantUUID = "12345";
 560         Map<GraphPropertyEnum, Object> propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class);
 561         propertiesToMatch.put(GraphPropertyEnum.INVARIANT_UUID, invariantUUID);
 562         when(janusGraphDaoMock.getByCriteria(null, propertiesToMatch, JsonParseFlagEnum.ParseMetadata)).
 563                 thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
 564         assertThrows(StorageException.class, () -> testInstance.deleteService(invariantUUID, true));
 565     }
 566
 567     @Test
 568     public void testMarkComponentToDelete() {
 569         StorageOperationStatus result;
 570         Component component = new Resource();
 571         String id = "id";
 572         component.setUniqueId(id);
 573         GraphVertex graphVertex = getTopologyTemplateVertex();
 574         when(janusGraphDaoMock.getVertexById(id, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex));
 575         when(nodeTypeOperationMock.markComponentToDelete(graphVertex)).thenReturn(Either.left(graphVertex));
 576         result = testInstance.markComponentToDelete(component);
 577         assertEquals(StorageOperationStatus.OK, result);
 578     }
 579
 580     @Test
 581     public void testDelToscaComponent() {
 582         Either<Component, StorageOperationStatus> result;
 583         String componentId = "compId";
 584         GraphVertex graphVertex = getTopologyTemplateVertex();
 585         ToscaElement toscaElement = getToscaElementForTest();
 586         when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex));
 587         when(topologyTemplateOperationMock.deleteToscaElement(graphVertex)).thenReturn(Either.left(toscaElement));
 588         result = testInstance.deleteToscaComponent(componentId);
 589         assertTrue(result.isLeft());
 590     }
 591
 592     @Test
 593     public void testGetLatestByToscaResourceName() {
 594         Either<Component, StorageOperationStatus> result;
 595         String toscaResourceName = "name";
 596         String model = "testModel";
 597         ToscaElement toscaElement = getToscaElementForTest();
 598
 599         Map<GraphPropertyEnum, Object> propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class);
 600         propertiesToMatch.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaResourceName);
 601         propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
 602         Map<GraphPropertyEnum, Object> propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class);
 603         propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true);
 604
 605         List<GraphVertex> graphVertexList = new ArrayList<>();
 606         GraphVertex graphVertex = getTopologyTemplateVertex();
 607         graphVertex.setUniqueId(toscaResourceName);
 608         Map<GraphPropertyEnum, Object> props = new HashMap<>();
 609         props.put(GraphPropertyEnum.VERSION, "1.0");
 610         graphVertex.setMetadataProperties(props);
 611         graphVertexList.add(graphVertex);
 612
 613         when(janusGraphDaoMock.getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseMetadata, model))
 614             .thenReturn(Either.left(graphVertexList));
 615         when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class)))
 616             .thenReturn(Either.left(toscaElement));
 617         result = testInstance.getLatestByToscaResourceName(toscaResourceName, model);
 618         assertTrue(result.isLeft());
 619     }
 620
 621
 622     @Test
 623     public void testGetLatestResourceByToscaResourceName() {
 624         Either<Resource, StorageOperationStatus> result;
 625         String toscaResourceName = "org.openecomp.resource.vf";
 626         ToscaElement toscaElement = getToscaElementForTest();
 627
 628         Map<GraphPropertyEnum, Object> propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class);
 629         propertiesToMatch.put(GraphPropertyEnum.TOSCA_RESOURCE_NAME, toscaResourceName);
 630         propertiesToMatch.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
 631         if (!toscaResourceName.contains("org.openecomp.resource.vf")) {
 632             propertiesToMatch.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name());
 633         }
 634
 635         List<GraphVertex> graphVertexList = new ArrayList<>();
 636         GraphVertex graphVertex = getTopologyTemplateVertex();
 637         graphVertex.setUniqueId(toscaResourceName);
 638         Map<JsonPresentationFields, Object> props = new HashMap<>();
 639         props.put(JsonPresentationFields.VERSION, "1.0");
 640         graphVertex.setJsonMetadataField(JsonPresentationFields.VERSION, props.get(JsonPresentationFields.VERSION));
 641         graphVertexList.add(graphVertex);
 642
 643         when(janusGraphDaoMock.getByCriteria(VertexTypeEnum.TOPOLOGY_TEMPLATE, propertiesToMatch, JsonParseFlagEnum.ParseMetadata))
 644             .thenReturn(Either.left(graphVertexList));
 645         when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class)))
 646             .thenReturn(Either.left(toscaElement));
 647
 648         when(janusGraphDaoMock.getVertexById(toscaResourceName, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex));
 649
 650         result = testInstance.getLatestResourceByToscaResourceName(toscaResourceName);
 651         assertTrue(result.isLeft());
 652     }
 653
 654     @Test
 655     public void testGetFollowed() {
 656         Either<Set<Component>, StorageOperationStatus> result;
 657         String userId = "id";
 658         Set<LifecycleStateEnum> lifecycleStates = new HashSet<>();
 659         Set<LifecycleStateEnum> lastStateStates = new HashSet<>();
 660         lifecycleStates.add(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
 661         lifecycleStates.add(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 662         lifecycleStates.add(LifecycleStateEnum.CERTIFIED);
 663         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 664         List<ToscaElement> toscaEleList = new ArrayList<>();
 665         ToscaElement toscaElement = getToscaElementForTest();
 666         toscaEleList.add(toscaElement);
 667         when(nodeTypeOperationMock.getFollowedComponent(userId, lifecycleStates, lastStateStates, componentType))
 668             .thenReturn(Either.left(toscaEleList));
 669         result = testInstance.getFollowed(userId, lifecycleStates, lastStateStates, componentType);
 670         assertTrue(result.isLeft());
 671         assertEquals(1, result.left().value().size());
 672     }
 673
 674     @Test
 675     public void testGetBySystemName() {
 676         Either<List<Component>, StorageOperationStatus> result;
 677         String sysName = "sysName";
 678         ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
 679         ToscaElement toscaElement = getToscaElementForTest();
 680         List<GraphVertex> componentVertices = new ArrayList<>();
 681         GraphVertex graphVertex = getTopologyTemplateVertex();
 682         componentVertices.add(graphVertex);
 683         Map<GraphPropertyEnum, Object> propertiesToMatch = new EnumMap<>(GraphPropertyEnum.class);
 684         Map<GraphPropertyEnum, Object> propertiesNotToMatch = new EnumMap<>(GraphPropertyEnum.class);
 685
 686         propertiesToMatch.put(GraphPropertyEnum.SYSTEM_NAME, sysName);
 687         propertiesToMatch.put(GraphPropertyEnum.COMPONENT_TYPE, componentTypeEnum.name());
 688
 689         propertiesNotToMatch.put(GraphPropertyEnum.IS_DELETED, true);
 690
 691         when(janusGraphDaoMock.getByCriteria(null, propertiesToMatch, propertiesNotToMatch, JsonParseFlagEnum.ParseAll))
 692             .thenReturn(Either.left(componentVertices));
 693         when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class)))
 694             .thenReturn(Either.left(toscaElement));
 695         result = testInstance.getBySystemName(componentTypeEnum, sysName);
 696         assertTrue(result.isLeft());
 697         assertEquals(1, result.left().value().size());
 698     }
 699
 700     @Test
 701     public void testGetCompByNameAndVersion() {
 702         Either<Component, StorageOperationStatus> result;
 703         ComponentTypeEnum componentType = ComponentTypeEnum.RESOURCE;
 704         String name = "name";
 705         String version = "1.0";
 706         JsonParseFlagEnum parseFlag = JsonParseFlagEnum.ParseAll;
 707         List<GraphVertex> graphVertexList = new ArrayList<>();
 708         GraphVertex graphVertex = getTopologyTemplateVertex();
 709         graphVertexList.add(graphVertex);
 710         ToscaElement toscaElement = getToscaElementForTest();
 711         Map<GraphPropertyEnum, Object> hasProperties = new EnumMap<>(GraphPropertyEnum.class);
 712         Map<GraphPropertyEnum, Object> hasNotProperties = new EnumMap<>(GraphPropertyEnum.class);
 713
 714         hasProperties.put(GraphPropertyEnum.NAME, name);
 715         hasProperties.put(GraphPropertyEnum.VERSION, version);
 716         hasNotProperties.put(GraphPropertyEnum.IS_DELETED, true);
 717         hasProperties.put(GraphPropertyEnum.COMPONENT_TYPE, componentType.name());
 718         when(janusGraphDaoMock.getByCriteria(null, hasProperties, hasNotProperties, parseFlag)).thenReturn(Either.left(graphVertexList));
 719         when(topologyTemplateOperationMock.getToscaElement(any(GraphVertex.class), any(ComponentParametersView.class)))
 720             .thenReturn(Either.left(toscaElement));
 721         result = testInstance.getComponentByNameAndVersion(componentType, name, version, parseFlag);
 722         assertTrue(result.isLeft());
 723     }
 724
 725     private ToscaElement getToscaElementForTest() {
 726         ToscaElement toscaElement = new TopologyTemplate();
 727         toscaElement.setComponentType(ComponentTypeEnum.RESOURCE);
 728         return toscaElement;
 729     }
 730
 731     @Test
 732     public void addDataTypesToComponentSuccessTest() {
 733         Either<List<DataTypeDefinition>, StorageOperationStatus> result = addDataTypesToComponentWithStatus(StorageOperationStatus.OK);
 734         assertTrue(result.isLeft());
 735     }
 736
 737     @Test
 738     public void addDataTypesToComponentFailureTest_BadRequest() {
 739         Either<List<DataTypeDefinition>, StorageOperationStatus> result = addDataTypesToComponentWithStatus(StorageOperationStatus.BAD_REQUEST);
 740         assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.BAD_REQUEST);
 741     }
 742
 743     private Either<List<DataTypeDefinition>, StorageOperationStatus> addDataTypesToComponentWithStatus(StorageOperationStatus status) {
 744         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 745         String componentId = "componentid";
 746         String Id = "id";
 747
 748         PropertyDefinition noDefaultProp = new PropertyDefinition();
 749         noDefaultProp.setName("noDefaultProp");
 750         PropertyDefinition prop1 = new PropertyDefinition();
 751         prop1.setDefaultValue("def1");
 752         prop1.setName("prop1");
 753         PropertyDefinition prop2 = new PropertyDefinition();
 754         prop2.setType("dataType1");
 755         prop2.setName("prop2");
 756         PropertyDefinition prop3 = new PropertyDefinition();
 757         prop3.setDefaultValue("def3");
 758         prop3.setName("prop3");
 759
 760         DataTypeDefinition noDefaultValue = new DataTypeDefinition();
 761         noDefaultValue.setProperties(Collections.singletonList(noDefaultProp));
 762         noDefaultValue.setDerivedFromName("name0");
 763
 764         DataTypeDefinition dataType1 = new DataTypeDefinition();
 765         dataType1.setProperties(Arrays.asList(prop1, prop3));
 766         dataType1.setName("name1");
 767         dataType1.setDerivedFromName("derivedfromname1");
 768
 769         DataTypeDefinition dataType2 = new DataTypeDefinition();
 770         dataType2.setDerivedFrom(dataType1);
 771         dataType2.setName("name2");
 772         dataType2.setDerivedFromName("derivedfromname2");
 773
 774         DataTypeDefinition dataType3 = new DataTypeDefinition();
 775         dataType3.setProperties(Collections.singletonList(prop2));
 776         dataType3.setDerivedFrom(noDefaultValue);
 777         dataType3.setName("name3");
 778         dataType3.setDerivedFromName("derivedfromname3");
 779
 780         dataTypes.put("noDefault", noDefaultValue);
 781         dataTypes.put("dataType1", dataType1);
 782         dataTypes.put("dataType2", dataType2);
 783         dataTypes.put("dataType3", dataType3);
 784
 785         GraphVertex vertex;
 786         if (status == StorageOperationStatus.OK) {
 787             vertex = getTopologyTemplateVertex();
 788         } else {
 789             vertex = getNodeTypeVertex();
 790         }
 791         Either<GraphVertex, JanusGraphOperationStatus> getVertexEither = Either.left(vertex);
 792         when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(getVertexEither);
 793         when(topologyTemplateOperationMock.addToscaDataToToscaElement(eq(vertex),
 794             eq(EdgeLabelEnum.DATA_TYPES), eq(VertexTypeEnum.DATA_TYPES), anyMap(), eq(JsonPresentationFields.NAME))).thenReturn(status);
 795         return testInstance.addDataTypesToComponent(dataTypes, componentId);
 796     }
 797
 798     @Test
 799     public void testDataTypesToComponentFailureTest_NotFound() {
 800         Either<List<DataTypeDefinition>, StorageOperationStatus> result;
 801         String componentId = "componentId";
 802         GraphVertex vertex = getNodeTypeVertex();
 803         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 804         when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(Either.right(
 805             JanusGraphOperationStatus.NOT_FOUND));
 806         result = testInstance.addDataTypesToComponent(dataTypes, componentId);
 807         assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.NOT_FOUND);
 808     }
 809
 810     @Test
 811     public void testDeleteDataTypeOfComponent() {
 812         Component component = new Resource();
 813         String id = "id";
 814         component.setUniqueId(id);
 815
 816         DataTypeDefinition dataType1 = new DataTypeDefinition();
 817         dataType1.setName("name1");
 818         Map<String, DataTypeDataDefinition> dataTypeDataMap = new HashMap<>();
 819         dataTypeDataMap.put("datatype1", dataType1);
 820         List<DataTypeDefinition> dataTypeMap = dataTypeDataMap.values().stream().map(e -> {
 821             return new DataTypeDefinition(e);
 822         }).collect(Collectors.toList());
 823         component.setDataTypes(dataTypeMap);
 824         GraphVertex graphVertex = getTopologyTemplateVertex();
 825         assertNull(testInstance.deleteDataTypeOfComponent(component, "datatype1"));
 826     }
 827
 828     @Test
 829     public void testAddComponentInstancePropertiesToComponent() {
 830         // set up component object
 831         Component component = new Resource();
 832         component.setUniqueId(COMPONENT_ID);
 833         List<ComponentInstanceProperty> instanceProps = new ArrayList<>();
 834         ComponentInstanceProperty instanceProp = new ComponentInstanceProperty();
 835         instanceProp.setName(PROPERTY1_NAME);
 836         instanceProp.setType(PROPERTY1_TYPE);
 837         instanceProps.add(instanceProp);
 838         instanceProp = new ComponentInstanceProperty();
 839         instanceProp.setName(PROPERTY2_NAME);
 840         instanceProp.setType(PROPERTY2_TYPE);
 841         instanceProps.add(instanceProp);
 842         Map<String, List<ComponentInstanceProperty>> instancePropsMap =
 843             Collections.singletonMap(COMPONENT_ID, instanceProps);
 844         component.setComponentInstancesProperties(Collections.singletonMap(COMPONENT_ID, new ArrayList<>()));
 845
 846         when(nodeTemplateOperationMock.addComponentInstanceProperty(any(), any(), any()))
 847             .thenReturn(StorageOperationStatus.OK);
 848
 849         Either<Map<String, List<ComponentInstanceProperty>>, StorageOperationStatus> result =
 850             testInstance.addComponentInstancePropertiesToComponent(component, instancePropsMap);
 851         assertTrue(result.isLeft());
 852         verify(nodeTemplateOperationMock, times(2)).addComponentInstanceProperty(any(), any(), any());
 853         List<ComponentInstanceProperty> resultProps = result.left().value().get(COMPONENT_ID);
 854         assertTrue(resultProps.stream().anyMatch(e -> e.getName().equals(PROPERTY1_NAME)));
 855         assertTrue(resultProps.stream().anyMatch(e -> e.getName().equals(PROPERTY2_NAME)));
 856     }
 857
 858     @Test
 859     public void testAddComponentInstanceToTopologyTemplate_ServiceProxy() {
 860         Component containerComponent = new Service();
 861         Component originalComponent = new Service();
 862         ComponentInstance componentInstance = new ComponentInstance();
 863         ComponentInstance existingComponentInstance = new ComponentInstance();
 864         User user = new User();
 865
 866         containerComponent.setComponentType(ComponentTypeEnum.SERVICE);
 867
 868         originalComponent.setComponentType(ComponentTypeEnum.SERVICE);
 869         originalComponent.setIcon(ICON_NAME);
 870
 871         componentInstance.setOriginType(OriginTypeEnum.ServiceProxy);
 872         componentInstance.setSourceModelName(SERVICE_MODEL_NAME);
 873
 874         List<ComponentInstance> existingInstances = new ArrayList<>();
 875         existingComponentInstance.setNormalizedName(SERVICE_PROXY_INSTANCE0_NAME);
 876         existingInstances.add(existingComponentInstance);
 877         containerComponent.setComponentInstances(existingInstances);
 878
 879         when(nodeTemplateOperationMock
 880             .addComponentInstanceToTopologyTemplate(any(), any(), eq("1"), eq(componentInstance), eq(false), eq(user)))
 881             .thenReturn(Either.left(new ImmutablePair<>(new TopologyTemplate(), COMPONENT_ID)));
 882         TopologyTemplate topologyTemplate = new TopologyTemplate();
 883         // preset COMPONENT_TYPE field for internal ModelConverter call
 884         topologyTemplate.setMetadataValue(JsonPresentationFields.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name());
 885         when(topologyTemplateOperationMock.getToscaElement(containerComponent.getUniqueId()))
 886             .thenReturn(Either.left(topologyTemplate));
 887
 888         Either<ImmutablePair<Component, String>, StorageOperationStatus> result =
 889             testInstance.addComponentInstanceToTopologyTemplate(
 890                 containerComponent, originalComponent, componentInstance, false, user);
 891
 892         assertTrue(result.isLeft());
 893         assertEquals(ICON_NAME, componentInstance.getIcon());
 894         assertEquals(COMPONENT_ID, result.left().value().getRight());
 895         // the instance counter must be 1 because the service proxy instance with suffix 0 already exists.
 896         verify(nodeTemplateOperationMock, times(1))
 897             .addComponentInstanceToTopologyTemplate(any(), any(), eq("1"), eq(componentInstance), eq(false), eq(user));
 898     }
 899
 900     @Test
 901     public void testAddComponentInstanceToTopologyTemplate_ServiceSubstitution() {
 902         Component containerComponent = new Service();
 903         Component originalComponent = new Service();
 904         ComponentInstance componentInstance = new ComponentInstance();
 905         ComponentInstance existingComponentInstance = new ComponentInstance();
 906         User user = new User();
 907
 908         containerComponent.setComponentType(ComponentTypeEnum.SERVICE);
 909
 910         originalComponent.setComponentType(ComponentTypeEnum.SERVICE);
 911         originalComponent.setIcon(ICON_NAME);
 912
 913         componentInstance.setOriginType(OriginTypeEnum.ServiceSubstitution);
 914         componentInstance.setSourceModelName(SERVICE_MODEL_NAME);
 915
 916         List<ComponentInstance> existingInstances = new ArrayList<>();
 917         existingComponentInstance.setNormalizedName(SERVICE_SUBSTITUTION_INSTANCE0_NAME);
 918         existingInstances.add(existingComponentInstance);
 919         containerComponent.setComponentInstances(existingInstances);
 920
 921         when(nodeTemplateOperationMock
 922             .addComponentInstanceToTopologyTemplate(any(), any(), eq("1"), eq(componentInstance), eq(false), eq(user)))
 923             .thenReturn(Either.left(new ImmutablePair<>(new TopologyTemplate(), COMPONENT_ID)));
 924         TopologyTemplate topologyTemplate = new TopologyTemplate();
 925         topologyTemplate.setMetadataValue(JsonPresentationFields.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name());
 926         when(topologyTemplateOperationMock.getToscaElement(containerComponent.getUniqueId()))
 927             .thenReturn(Either.left(topologyTemplate));
 928
 929         Either<ImmutablePair<Component, String>, StorageOperationStatus> result =
 930             testInstance.addComponentInstanceToTopologyTemplate(
 931                 containerComponent, originalComponent, componentInstance, false, user);
 932
 933         assertTrue(result.isLeft());
 934         assertEquals(ICON_NAME, componentInstance.getIcon());
 935         assertEquals(COMPONENT_ID, result.left().value().getRight());
 936         verify(nodeTemplateOperationMock, times(1))
 937             .addComponentInstanceToTopologyTemplate(any(), any(), eq("1"), eq(componentInstance), eq(false), eq(user));
 938     }
 939
 940     @Test
 941     public void testUpdateComponentInstanceRequirement() {
 942         String containerComponentId = "containerComponentId";
 943         String componentInstanceUniqueId = "componentInstanceUniqueId";
 944         RequirementDataDefinition requirementDataDefinition = Mockito.mock(RequirementDataDefinition.class);
 945
 946         when(nodeTemplateOperationMock.updateComponentInstanceRequirement(containerComponentId, componentInstanceUniqueId, requirementDataDefinition))
 947             .thenReturn(StorageOperationStatus.OK);
 948         StorageOperationStatus result = testInstance
 949             .updateComponentInstanceRequirement(containerComponentId, componentInstanceUniqueId, requirementDataDefinition);
 950         assertEquals(StorageOperationStatus.OK, result);
 951         verify(nodeTemplateOperationMock, times(1))
 952             .updateComponentInstanceRequirement(containerComponentId, componentInstanceUniqueId, requirementDataDefinition);
 953
 954     }
 955
 956     @Test
 957     public void associateCapabilitiesToServiceFailureTest() {
 958         StorageOperationStatus result = associateCapabilitiesToServiceWithStatus(StorageOperationStatus.BAD_REQUEST);
 959         assertSame(StorageOperationStatus.BAD_REQUEST, result);
 960     }
 961
 962     @Test
 963     public void associateCapabilitiesToServiceSuccessTest() {
 964         StorageOperationStatus result = associateCapabilitiesToServiceWithStatus(StorageOperationStatus.OK);
 965         assertSame(StorageOperationStatus.OK, result);
 966     }
 967
 968     private StorageOperationStatus associateCapabilitiesToServiceWithStatus(StorageOperationStatus status) {
 969         Map<String, ListCapabilityDataDefinition> capabilitiesMap = new HashedMap();
 970         String componentId = "componentid";
 971
 972         ListCapabilityDataDefinition listCapabilityDataDefinition1 = new ListCapabilityDataDefinition();
 973         capabilitiesMap.put("capabilities1", listCapabilityDataDefinition1);
 974
 975         GraphVertex vertex;
 976         if (status == StorageOperationStatus.OK) {
 977             vertex = getTopologyTemplateVertex();
 978         } else {
 979             vertex = getNodeTypeVertex();
 980         }
 981
 982         Either<GraphVertex, JanusGraphOperationStatus> getVertexEither = Either.left(vertex);
 983         when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(getVertexEither);
 984         when(topologyTemplateOperationMock.associateElementToData(eq(vertex),
 985             eq(VertexTypeEnum.CAPABILITIES), eq(EdgeLabelEnum.CAPABILITIES), anyMap())).thenReturn(Either.right(status));
 986         return testInstance.associateCapabilitiesToService(capabilitiesMap, componentId);
 987     }
 988
 989     @Test
 990     public void associateRequirementsToServiceFailureTest() {
 991         StorageOperationStatus result = associateRequirementsToServiceWithStatus(StorageOperationStatus.BAD_REQUEST);
 992         assertSame(StorageOperationStatus.BAD_REQUEST, result);
 993     }
 994
 995     @Test
 996     public void associateRequirementsToServiceSuccessTest() {
 997         StorageOperationStatus result = associateRequirementsToServiceWithStatus(StorageOperationStatus.OK);
 998         assertSame(StorageOperationStatus.OK, result);
 999     }
1000
1001     @Test
1002     public void test_addOutputsToComponent() {
1003         final GraphVertex graphVertex = getTopologyTemplateVertex();
1004         final String componentId = "componentId";
1005
1006         doReturn(Either.left(graphVertex)).when(janusGraphDaoMock).getVertexById(componentId, JsonParseFlagEnum.NoParse);
1007         doReturn(StorageOperationStatus.OK).when(topologyTemplateOperationMock)
1008             .addToscaDataToToscaElement(
1009                 any(GraphVertex.class), eq(EdgeLabelEnum.OUTPUTS), eq(VertexTypeEnum.OUTPUTS), anyMap(), eq(JsonPresentationFields.NAME));
1010
1011         final Map<String, OutputDefinition> outputs = new HashMap<>();
1012         final OutputDefinition outputDefinition = new OutputDefinition();
1013         outputs.put("mock", outputDefinition);
1014         final Either<List<OutputDefinition>, StorageOperationStatus> result = testInstance.addOutputsToComponent(outputs, componentId);
1015         assertNotNull(result);
1016         assertTrue(result.isLeft());
1017         assertFalse(result.left().value().isEmpty());
1018         assertThat(result.left().value().get(0)).isInstanceOf(OutputDefinition.class);
1019         verify(janusGraphDaoMock, times(1)).getVertexById(componentId, JsonParseFlagEnum.NoParse);
1020         verify(topologyTemplateOperationMock, times(1)).addToscaDataToToscaElement(
1021             any(GraphVertex.class), eq(EdgeLabelEnum.OUTPUTS), eq(VertexTypeEnum.OUTPUTS), anyMap(), eq(JsonPresentationFields.NAME));
1022     }
1023
1024     @Test
1025     public void test_addComponentInstanceOutputsToComponent_updateComponentInstanceOutput() {
1026         final Component component = new Resource();
1027         component.setUniqueId(COMPONENT_ID);
1028         final Map<String, List<ComponentInstanceOutput>> map = new HashMap<>();
1029         final List<ComponentInstanceOutput> componentInstanceOutputList = new ArrayList<>();
1030         final ComponentInstanceOutput componentInstanceOutput = new ComponentInstanceOutput();
1031         componentInstanceOutput.setComponentInstanceId(COMPONENT_ID);
1032         componentInstanceOutput.setComponentInstanceName(COMPONENT_ID);
1033         componentInstanceOutput.setName(COMPONENT_ID);
1034         componentInstanceOutputList.add(componentInstanceOutput);
1035         map.put("mock", componentInstanceOutputList);
1036         component.setComponentInstancesOutputs(map);
1037
1038         doReturn(StorageOperationStatus.OK).when(nodeTemplateOperationMock)
1039             .updateComponentInstanceOutput(any(Component.class), anyString(), any(ComponentInstanceOutput.class));
1040
1041         final Either<Map<String, List<ComponentInstanceOutput>>, StorageOperationStatus> result
1042             = testInstance.addComponentInstanceOutputsToComponent(component, map);
1043         assertNotNull(result);
1044         assertTrue(result.isLeft());
1045         assertFalse(result.left().value().isEmpty());
1046         assertSame(result.left().value(), map);
1047         verify(nodeTemplateOperationMock, times(1))
1048             .updateComponentInstanceOutput(any(Component.class), anyString(), any(ComponentInstanceOutput.class));
1049
1050     }
1051
1052     @Test
1053     public void test_addComponentInstanceOutputsToComponent_addComponentInstanceOutput() {
1054         final Component component = new Resource();
1055         component.setUniqueId(COMPONENT_ID);
1056         Map<String, List<ComponentInstanceOutput>> map = new HashMap<>();
1057         List<ComponentInstanceOutput> componentInstanceOutputList = new ArrayList<>();
1058         ComponentInstanceOutput componentInstanceOutput = new ComponentInstanceOutput();
1059         componentInstanceOutput.setComponentInstanceId(COMPONENT_ID);
1060         componentInstanceOutput.setComponentInstanceName(COMPONENT_ID);
1061         componentInstanceOutput.setName(COMPONENT_ID);
1062         componentInstanceOutputList.add(componentInstanceOutput);
1063         map.put("mock", componentInstanceOutputList);
1064         component.setComponentInstancesOutputs(map);
1065
1066         map = new HashMap<>();
1067         componentInstanceOutputList = new ArrayList<>();
1068         componentInstanceOutput = new ComponentInstanceOutput();
1069         componentInstanceOutput.setComponentInstanceId("mock");
1070         componentInstanceOutput.setComponentInstanceName("mock");
1071         componentInstanceOutput.setName("mock");
1072         componentInstanceOutputList.add(componentInstanceOutput);
1073         map.put("mock", componentInstanceOutputList);
1074
1075         final Either<Map<String, List<ComponentInstanceOutput>>, StorageOperationStatus> result = testInstance
1076             .addComponentInstanceOutputsToComponent(component, map);
1077         assertNotNull(result);
1078         assertTrue(result.isRight());
1079     }
1080
1081     @Test
1082     public void test_addComponentInstanceAttributesToComponent() {
1083         final Component component = new Resource();
1084         component.setUniqueId(COMPONENT_ID);
1085         Map<String, List<ComponentInstanceAttribute>> map = new HashMap<>();
1086         List<ComponentInstanceAttribute> componentInstanceOutputList = new ArrayList<>();
1087         ComponentInstanceAttribute componentInstanceAttribute = new ComponentInstanceAttribute();
1088         componentInstanceAttribute.setComponentInstanceId(COMPONENT_ID);
1089         componentInstanceAttribute.setUniqueId(COMPONENT_ID);
1090         componentInstanceOutputList.add(componentInstanceAttribute);
1091         map.put("mock", componentInstanceOutputList);
1092         component.setComponentInstancesAttributes(map);
1093
1094         doReturn(StorageOperationStatus.OK).when(nodeTemplateOperationMock)
1095             .updateComponentInstanceAttribute(any(Component.class), anyString(), any(ComponentInstanceAttribute.class));
1096
1097         final Either<Map<String, List<ComponentInstanceAttribute>>, StorageOperationStatus> result
1098             = testInstance.addComponentInstanceAttributesToComponent(component, map);
1099
1100         assertNotNull(result);
1101         assertTrue(result.isLeft());
1102         assertFalse(result.left().value().isEmpty());
1103         assertSame(result.left().value(), map);
1104         verify(nodeTemplateOperationMock, times(1))
1105             .updateComponentInstanceAttribute(any(Component.class), anyString(), any(ComponentInstanceAttribute.class));
1106     }
1107
1108     @Test
1109     public void test_updateAttributeOfComponent_success() {
1110         final GraphVertex graphVertex = getTopologyTemplateVertex();
1111         final String componentId = "componentId";
1112         final Component component = new Resource();
1113         component.setUniqueId(COMPONENT_ID);
1114         doReturn(StorageOperationStatus.OK).when(nodeTypeOperationMock).updateToscaDataOfToscaElement(
1115             anyString(), eq(EdgeLabelEnum.ATTRIBUTES), eq(VertexTypeEnum.ATTRIBUTES), any(AttributeDefinition.class),
1116             eq(JsonPresentationFields.NAME));
1117         doReturn(Either.left(graphVertex)).when(janusGraphDaoMock).getVertexById(eq(componentId), any(JsonParseFlagEnum.class));
1118
1119         final ToscaElement toscaElement = getToscaElementForTest();
1120         final Map<String, AttributeDataDefinition> attributes = new HashMap<>();
1121         final AttributeDefinition attributeDefinition = new AttributeDefinition();
1122         attributeDefinition.setName("mock");
1123         attributes.put("mock", attributeDefinition);
1124         toscaElement.setAttributes(attributes);
1125         doReturn(Either.left(toscaElement)).when(topologyTemplateOperationMock)
1126             .getToscaElement(ArgumentMatchers.eq(graphVertex), any(ComponentParametersView.class));
1127
1128         final Either<AttributeDefinition, StorageOperationStatus> result
1129             = testInstance.updateAttributeOfComponent(component, attributeDefinition);
1130         assertNotNull(result);
1131     }
1132
1133     @Test
1134     public void test_updateAttributeOfComponent_isNotPresent() {
1135         final GraphVertex graphVertex = getTopologyTemplateVertex();
1136         final String componentId = "componentId";
1137         final Component component = new Resource();
1138         component.setUniqueId(COMPONENT_ID);
1139         doReturn(StorageOperationStatus.OK).when(nodeTypeOperationMock).updateToscaDataOfToscaElement(
1140             anyString(), eq(EdgeLabelEnum.ATTRIBUTES), eq(VertexTypeEnum.ATTRIBUTES), any(AttributeDefinition.class),
1141             eq(JsonPresentationFields.NAME));
1142         doReturn(Either.left(graphVertex)).when(janusGraphDaoMock).getVertexById(eq(componentId), any(JsonParseFlagEnum.class));
1143
1144         final ToscaElement toscaElement = getToscaElementForTest();
1145         final Map<String, AttributeDataDefinition> attributes = new HashMap<>();
1146         final AttributeDefinition attributeDefinition = new AttributeDefinition();
1147         attributeDefinition.setName("mock");
1148         attributes.put("mock", attributeDefinition);
1149         toscaElement.setAttributes(attributes);
1150         doReturn(Either.left(toscaElement)).when(topologyTemplateOperationMock)
1151             .getToscaElement(ArgumentMatchers.eq(graphVertex), any(ComponentParametersView.class));
1152
1153         final AttributeDefinition attributeDefinitionOneMore = new AttributeDefinition();
1154         attributeDefinitionOneMore.setName("Anothermock");
1155
1156         final Either<AttributeDefinition, StorageOperationStatus> result
1157             = testInstance.updateAttributeOfComponent(component, attributeDefinitionOneMore);
1158         assertNotNull(result);
1159     }
1160
1161     @Test
1162     public void test_updateComponentInstanceAttributes() {
1163         final GraphVertex graphVertex = getTopologyTemplateVertex();
1164         final String componentId = "componentId";
1165         final Component component = new Resource();
1166         component.setUniqueId(COMPONENT_ID);
1167
1168         final List<ComponentInstanceAttribute> attributes = new ArrayList<>();
1169         final ComponentInstanceAttribute attributeDefinition = new ComponentInstanceAttribute();
1170         attributeDefinition.setName("mock");
1171         attributes.add(attributeDefinition);
1172
1173         doReturn(StorageOperationStatus.OK).when(nodeTemplateOperationMock).updateComponentInstanceAttributes(component, componentId, attributes);
1174
1175         final StorageOperationStatus result = testInstance.updateComponentInstanceAttributes(component, componentId, attributes);
1176         assertNotNull(result);
1177         assertEquals(StorageOperationStatus.OK, result);
1178         verify(nodeTemplateOperationMock, times(1)).updateComponentInstanceAttributes(component, componentId, attributes);
1179     }
1180
1181     @Test
1182     public void test_updateComponentInstanceOutputs() {
1183         final GraphVertex graphVertex = getTopologyTemplateVertex();
1184         final String componentId = "componentId";
1185         final Component component = new Resource();
1186         component.setUniqueId(COMPONENT_ID);
1187
1188         final List<ComponentInstanceOutput> list = new ArrayList<>();
1189         final ComponentInstanceOutput output = new ComponentInstanceOutput();
1190         output.setName("mock");
1191         list.add(output);
1192
1193         doReturn(StorageOperationStatus.OK).when(nodeTemplateOperationMock).updateComponentInstanceOutputs(component, componentId, list);
1194
1195         final StorageOperationStatus result = testInstance.updateComponentInstanceOutputs(component, componentId, list);
1196         assertNotNull(result);
1197         assertEquals(StorageOperationStatus.OK, result);
1198         verify(nodeTemplateOperationMock, times(1)).updateComponentInstanceOutputs(component, componentId, list);
1199     }
1200
1201     @Test
1202     public void test_deleteOutputOfResource() {
1203         final Component component = new Resource();
1204         component.setUniqueId(COMPONENT_ID);
1205
1206         doReturn(StorageOperationStatus.OK).when(nodeTypeOperationMock)
1207             .deleteToscaDataElement(anyString(), eq(EdgeLabelEnum.OUTPUTS), eq(VertexTypeEnum.OUTPUTS), anyString(), eq(JsonPresentationFields.NAME));
1208
1209         final StorageOperationStatus result = testInstance.deleteOutputOfResource(component, "mock");
1210         assertNotNull(result);
1211         assertEquals(StorageOperationStatus.OK, result);
1212         verify(nodeTypeOperationMock, times(1))
1213             .deleteToscaDataElement(anyString(), eq(EdgeLabelEnum.OUTPUTS), eq(VertexTypeEnum.OUTPUTS), anyString(), eq(JsonPresentationFields.NAME));
1214     }
1215
1216     private StorageOperationStatus associateRequirementsToServiceWithStatus(StorageOperationStatus status) {
1217         Map<String, ListRequirementDataDefinition> requirementsMap = new HashedMap();
1218         String componentId = "componentid";
1219
1220         ListRequirementDataDefinition listRequirementDataDefinition1 = new ListRequirementDataDefinition();
1221         requirementsMap.put("requirements1", listRequirementDataDefinition1);
1222
1223         GraphVertex vertex;
1224         if (status == StorageOperationStatus.OK) {
1225             vertex = getTopologyTemplateVertex();
1226         } else {
1227             vertex = getNodeTypeVertex();
1228         }
1229
1230         Either<GraphVertex, JanusGraphOperationStatus> getVertexEither = Either.left(vertex);
1231         when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(getVertexEither);
1232         when(topologyTemplateOperationMock.associateElementToData(eq(vertex),
1233             eq(VertexTypeEnum.REQUIREMENTS), eq(EdgeLabelEnum.REQUIREMENTS), anyMap())).thenReturn(Either.right(status));
1234         return testInstance.associateRequirementsToService(requirementsMap, componentId);
1235     }
1236
1237     private Either<PolicyDefinition, StorageOperationStatus> associatePolicyToComponentWithStatus(StorageOperationStatus status) {
1238         PolicyDefinition policy = new PolicyDefinition();
1239         String componentId = "componentId";
1240         int counter = 0;
1241         GraphVertex vertex;
1242         if (status == StorageOperationStatus.OK) {
1243             vertex = getTopologyTemplateVertex();
1244         } else {
1245             vertex = getNodeTypeVertex();
1246         }
1247         Either<GraphVertex, JanusGraphOperationStatus> getVertexEither = Either.left(vertex);
1248         when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.ParseMetadata)).thenReturn(getVertexEither);
1249         when(topologyTemplateOperationMock.addPolicyToToscaElement(eq(vertex), any(PolicyDefinition.class), anyInt())).thenReturn(status);
1250         return testInstance.associatePolicyToComponent(componentId, policy, counter);
1251     }
1252
1253     private Either<PolicyDefinition, StorageOperationStatus> updatePolicyOfComponentWithStatus(StorageOperationStatus status) {
1254         PolicyDefinition policy = new PolicyDefinition();
1255         String componentId = "componentId";
1256         GraphVertex vertex = getTopologyTemplateVertex();
1257         when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(vertex));
1258         when(topologyTemplateOperationMock.updatePolicyOfToscaElement(eq(vertex), any(PolicyDefinition.class))).thenReturn(status);
1259         return testInstance.updatePolicyOfComponent(componentId, policy, PromoteVersionEnum.NONE);
1260     }
1261
1262     private void removePolicyFromComponentWithStatus(StorageOperationStatus status) {
1263         String componentId = "componentId";
1264         String policyId = "policyId";
1265         GraphVertex vertex = getTopologyTemplateVertex();
1266         Either<GraphVertex, JanusGraphOperationStatus> getVertexEither = Either.left(vertex);
1267         when(janusGraphDaoMock.getVertexById(componentId, JsonParseFlagEnum.NoParse)).thenReturn(getVertexEither);
1268         when(topologyTemplateOperationMock.removePolicyFromToscaElement(vertex, policyId)).thenReturn(status);
1269         StorageOperationStatus result = testInstance.removePolicyFromComponent(componentId, policyId);
1270         assertSame(result, status);
1271     }
1272
1273     private List<GraphVertex> getMockVertices(int numOfVertices) {
1274         return IntStream.range(0, numOfVertices).mapToObj(i -> getTopologyTemplateVertex()).collect(Collectors.toList());
1275     }
1276
1277     private ToscaElement getResourceToscaElement(String id) {
1278         ToscaElement toscaElement = new TopologyTemplate();
1279         toscaElement.setMetadata(new HashMap<>());
1280         toscaElement.getMetadata().put(JsonPresentationFields.COMPONENT_TYPE.getPresentation(), "RESOURCE");
1281         toscaElement.getMetadata().put(JsonPresentationFields.UNIQUE_ID.getPresentation(), id);
1282         return toscaElement;
1283     }
1284
1285     private GraphVertex getTopologyTemplateVertex() {
1286         GraphVertex graphVertex = new GraphVertex();
1287         graphVertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE);
1288         return graphVertex;
1289     }
1290
1291     private GraphVertex getNodeTypeVertex() {
1292         GraphVertex graphVertex = new GraphVertex();
1293         graphVertex.setLabel(VertexTypeEnum.NODE_TYPE);
1294         return graphVertex;
1295     }
1296 }