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