catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaOperationFacadeTest.java

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