catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTemplateOperationTest.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 com.google.common.collect.Lists;
  33 import fj.data.Either;
  34 import org.apache.commons.lang3.tuple.ImmutablePair;
  35 import org.apache.tinkerpop.gremlin.structure.Direction;
  36 import org.apache.tinkerpop.gremlin.structure.Edge;
  37 import org.apache.tinkerpop.gremlin.structure.Vertex;
  38 import org.janusgraph.core.JanusGraphVertex;
  39 import org.junit.jupiter.api.BeforeAll;
  40 import org.junit.jupiter.api.Test;
  41 import org.junit.jupiter.api.TestInstance;
  42 import org.junit.jupiter.api.TestInstance.Lifecycle;
  43 import org.junit.jupiter.api.extension.ExtendWith;
  44 import org.mockito.ArgumentMatchers;
  45 import org.mockito.InjectMocks;
  46 import org.mockito.Mock;
  47 import org.mockito.Mockito;
  48 import org.mockito.junit.MockitoJUnitRunner;
  49 import org.mockito.junit.jupiter.MockitoExtension;
  50 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  51 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  52 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
  53 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  54 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  55 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  56 import org.openecomp.sdc.be.datatypes.elements.*;
  57 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
  58 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  59 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  60 import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
  61 import org.openecomp.sdc.be.model.*;
  62 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate;
  63 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement;
  64 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  65 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  66
  67 import java.util.ArrayList;
  68 import java.util.HashMap;
  69 import java.util.Iterator;
  70 import java.util.List;
  71 import java.util.Map;
  72
  73 import static org.codehaus.groovy.runtime.DefaultGroovyMethods.any;
  74 import static org.junit.jupiter.api.Assertions.assertEquals;
  75 import static org.junit.jupiter.api.Assertions.assertNotNull;
  76 import static org.junit.jupiter.api.Assertions.assertSame;
  77 import static org.junit.jupiter.api.Assertions.assertTrue;
  78 import static org.mockito.ArgumentMatchers.anyList;
  79 import static org.mockito.ArgumentMatchers.anyString;
  80 import static org.mockito.ArgumentMatchers.eq;
  81 import static org.mockito.Mockito.doReturn;
  82 import static org.mockito.Mockito.times;
  83 import static org.mockito.Mockito.verify;
  84 import static org.mockito.Mockito.when;
  85
  86 @ExtendWith(MockitoExtension.class)
  87 @TestInstance(Lifecycle.PER_CLASS)
  88 class NodeTemplateOperationTest extends ModelTestBase {
  89
  90     private static final String COMPONENT_ID = "componentId";
  91     private static final String TO_INSTANCE_ID = "toInstanceId";
  92     private static final String FROM_INSTANCE_ID = "fromInstanceId";
  93     private static final String RELATION_ID = "relationId";
  94     private static final String CAPABILITY_OWNER_ID = "capabilityOwnerId";
  95     private static final String CAPABILITY_UID = "capabilityUid";
  96     private static final String CAPABILITY_NAME = "capabilityName";
  97     private static final String REQUIREMENT_OWNER_ID = "requirementOwnerId";
  98     private static final String REQUIREMENT_UID = "requirementUid";
  99     private static final String REQUIREMENT_NAME = "requirementName";
 100     private static final String RELATIONSHIP_TYPE = "relationshipType";
 101
 102     private static Map<String, MapListCapabilityDataDefinition> fulfilledCapability;
 103     private static Map<String, MapListRequirementDataDefinition> fulfilledRequirement;
 104     private static CapabilityDataDefinition capability;
 105     private static RequirementDataDefinition requirement;
 106     private static RequirementCapabilityRelDef relation;
 107
 108     private final JanusGraphDao janusGraphDao = Mockito.mock(JanusGraphDao.class);
 109     private final TopologyTemplateOperation topologyTemplateOperation = Mockito.mock(TopologyTemplateOperation.class);
 110
 111     @InjectMocks
 112     private NodeTemplateOperation operation;
 113
 114     @BeforeAll
 115     public void setup() {
 116         init();
 117         operation = new NodeTemplateOperation();
 118         operation.setJanusGraphDao(janusGraphDao);
 119         buildDataDefinition();
 120     }
 121
 122     private static void buildDataDefinition() {
 123         buildCapabiltyDataDefinition();
 124         buildRequirementDataDefinition();
 125         buildRelation();
 126     }
 127
 128     @Test
 129     void testGetFulfilledCapabilityByRelationSuccess() {
 130         GraphVertex vertex = Mockito.mock(GraphVertex.class);
 131         Either<GraphVertex, JanusGraphOperationStatus> vertexRes = Either.left(vertex);
 132         when(janusGraphDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
 133
 134         GraphVertex dataVertex = new GraphVertex();
 135         dataVertex.setJson(fulfilledCapability);
 136         Either<GraphVertex, JanusGraphOperationStatus> childVertexRes = Either.left(dataVertex);
 137         when(janusGraphDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_CAPABILITIES), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes);
 138         Either<CapabilityDataDefinition, StorageOperationStatus> result = operation.getFulfilledCapabilityByRelation(COMPONENT_ID, TO_INSTANCE_ID, relation, this::isBelongingCapability);
 139         assertTrue(result.isLeft());
 140         assertEquals(result.left().value(), capability);
 141     }
 142
 143     @Test
 144     void testGetFulfilledRequirementByRelationSuccess() {
 145         GraphVertex vertex = Mockito.mock(GraphVertex.class);
 146         Either<GraphVertex, JanusGraphOperationStatus> vertexRes = Either.left(vertex);
 147         when(janusGraphDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
 148
 149         GraphVertex dataVertex = new GraphVertex();
 150         dataVertex.setJson(fulfilledRequirement);
 151         Either<GraphVertex, JanusGraphOperationStatus> childVertexRes = Either.left(dataVertex);
 152         when(janusGraphDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_REQUIREMENTS), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes);
 153         Either<RequirementDataDefinition, StorageOperationStatus> result = operation.getFulfilledRequirementByRelation(COMPONENT_ID, FROM_INSTANCE_ID, relation, this::isBelongingRequirement);
 154         assertTrue(result.isLeft());
 155         assertEquals(result.left().value(), requirement);
 156     }
 157
 158     @Test
 159     void testGetFulfilledCapabilityByRelationNotFoundFailure() {
 160         GraphVertex vertex = Mockito.mock(GraphVertex.class);
 161         Either<GraphVertex, JanusGraphOperationStatus> vertexRes = Either.left(vertex);
 162         when(janusGraphDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
 163
 164         Either<GraphVertex, JanusGraphOperationStatus> childVertexRes = Either.right(
 165             JanusGraphOperationStatus.NOT_FOUND);
 166         when(janusGraphDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_CAPABILITIES), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes);
 167         Either<CapabilityDataDefinition, StorageOperationStatus> result = operation.getFulfilledCapabilityByRelation(COMPONENT_ID, TO_INSTANCE_ID, relation, this::isBelongingCapability);
 168         assertTrue(result.isRight());
 169         assertSame(StorageOperationStatus.NOT_FOUND, result.right().value());
 170     }
 171
 172     @Test
 173     void testGetFulfilledRequirementByRelationNotFoundFailure() {
 174         GraphVertex vertex = Mockito.mock(GraphVertex.class);
 175         Either<GraphVertex, JanusGraphOperationStatus> vertexRes = Either.left(vertex);
 176         when(janusGraphDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes);
 177
 178         Either<GraphVertex, JanusGraphOperationStatus> childVertexRes = Either.right(
 179             JanusGraphOperationStatus.NOT_FOUND);
 180         when(janusGraphDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_REQUIREMENTS), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes);
 181         Either<RequirementDataDefinition, StorageOperationStatus> result = operation.getFulfilledRequirementByRelation(COMPONENT_ID, FROM_INSTANCE_ID, relation, this::isBelongingRequirement);
 182         assertTrue(result.isRight());
 183         assertSame(StorageOperationStatus.NOT_FOUND, result.right().value());
 184     }
 185
 186     @Test
 187     void testUpdateCIMetadataOfTopologyTemplate() {
 188         Either<ImmutablePair<TopologyTemplate, String>, StorageOperationStatus> result;
 189         String id = "id";
 190         TopologyTemplate container = new TopologyTemplate();
 191         ToscaElement toscaElement = new TopologyTemplate();
 192         toscaElement.setResourceType(ResourceTypeEnum.VF);
 193         ComponentInstance componentInstance = new ComponentInstance();
 194         componentInstance.setName(id);
 195         componentInstance.setComponentUid(id);
 196         container.setUniqueId(id);
 197         GraphVertex graphVertex = new GraphVertex();
 198         when(janusGraphDao.getVertexById(container.getUniqueId(), JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(graphVertex));
 199         when(janusGraphDao.updateVertex(graphVertex)).thenReturn(Either.left(graphVertex));
 200         when(topologyTemplateOperation.getToscaElement(anyString())).thenReturn(Either.left(toscaElement));
 201
 202         result = operation.updateComponentInstanceMetadataOfTopologyTemplate(container, toscaElement, componentInstance);
 203         assertTrue(result.isLeft());
 204     }
 205
 206     @Test
 207     void testGetDefaultHeatTimeout() {
 208         Integer result;
 209
 210         // default test
 211         result = NodeTemplateOperation.getDefaultHeatTimeout();
 212     }
 213
 214     @Test
 215     void testPrepareInstDeploymentArtifactPerInstance() {
 216         Map<String, Object> deploymentResourceArtifacts = new HashMap<>();
 217         Map<String, ArtifactDataDefinition> deploymentArtifacts = new HashMap<>();
 218         ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 219         artifactDataDefinition.setArtifactType("HEAT");
 220         artifactDataDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 221         deploymentArtifacts.put("1", artifactDataDefinition);
 222         deploymentResourceArtifacts.put("1", artifactDataDefinition);
 223         String componentInstanceId = "componentInstanceId";
 224         User user = new User();
 225         user.setUserId("userId");
 226         user.setFirstName("first");
 227         user.setLastName("last");
 228         String envType = "VfHeatEnv";
 229         MapArtifactDataDefinition result;
 230
 231         result = operation.prepareInstDeploymentArtifactPerInstance(deploymentArtifacts, componentInstanceId, user,
 232             envType);
 233         assertEquals(2, result.getMapToscaDataDefinition().size());
 234     }
 235
 236     @Test
 237     void testCreateCapPropertyKey() throws Exception {
 238         String key = "";
 239         String instanceId = "";
 240         String result;
 241
 242         // default test
 243         result = NodeTemplateOperation.createCapPropertyKey(key, instanceId);
 244     }
 245
 246     @Test
 247     void testPrepareCalculatedCapabiltyForNodeType() {
 248         Map<String, ListCapabilityDataDefinition> capabilities = new HashMap<>();
 249         ListCapabilityDataDefinition listCapDataDefinition = new ListCapabilityDataDefinition();
 250         List<CapabilityDataDefinition> listToscaDataDefinition = new ArrayList<>();
 251         CapabilityDataDefinition capabilityDataDefinition = new CapabilityDefinition();
 252         capabilityDataDefinition.setMaxOccurrences("1");
 253         listToscaDataDefinition.add(capabilityDataDefinition);
 254         listCapDataDefinition.setListToscaDataDefinition(listToscaDataDefinition);
 255         capabilities.put("1", listCapDataDefinition);
 256         ComponentInstance componentInstance = createCompInstance();
 257         MapListCapabilityDataDefinition result;
 258
 259         result = operation.prepareCalculatedCapabiltyForNodeType(capabilities, componentInstance);
 260         assertEquals(1, result.getMapToscaDataDefinition().size());
 261         }
 262
 263     @Test
 264     void testPrepareCalculatedReqForNodeType() {
 265         Map<String, ListRequirementDataDefinition> requirements = new HashMap<>();
 266         ListRequirementDataDefinition listReqDataDef = new ListRequirementDataDefinition();
 267         List<RequirementDataDefinition> listToscaDataDefinition = new ArrayList<>();
 268         RequirementDataDefinition reqDataDefinition = new RequirementDataDefinition();
 269         reqDataDefinition.setMaxOccurrences("1");
 270         listToscaDataDefinition.add(reqDataDefinition);
 271         listReqDataDef.setListToscaDataDefinition(listToscaDataDefinition);
 272         requirements.put("1", listReqDataDef);
 273         ComponentInstance componentInstance = createCompInstance();
 274         MapListRequirementDataDefinition result;
 275
 276         result = operation.prepareCalculatedRequirementForNodeType(requirements, componentInstance);
 277         assertEquals(1, result.getMapToscaDataDefinition().size());
 278     }
 279
 280     @Test
 281     void testAddGroupInstancesToComponentInstance() throws Exception {
 282         Component containerComponent = null;
 283         ComponentInstanceDataDefinition componentInstance = null;
 284         List<GroupDefinition> groups = null;
 285         Map<String, List<ArtifactDefinition>> groupInstancesArtifacts = null;
 286         StorageOperationStatus result;
 287
 288         result = operation.addGroupInstancesToComponentInstance(containerComponent, componentInstance, groups,
 289             groupInstancesArtifacts);
 290         assertEquals(StorageOperationStatus.OK, result);
 291     }
 292
 293     @Test
 294     void testGenerateCustomizationUUIDOnInstanceGroup() throws Exception {
 295         String componentId = "";
 296         String instanceId = "";
 297         List<String> groupInstances = null;
 298         StorageOperationStatus result;
 299
 300         result = operation.generateCustomizationUUIDOnInstanceGroup(componentId, instanceId, groupInstances);
 301         assertEquals(StorageOperationStatus.OK, result);
 302     }
 303
 304     @Test
 305     void testUpdateComponentInstanceRequirement() {
 306         String componentId = "";
 307         String componentInstanceId = "requirementOwnerId";
 308
 309         GraphVertex graphVertex = new GraphVertex();
 310         graphVertex.setUniqueId("uniqueId");
 311         when(janusGraphDao.getVertexById(componentId, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(graphVertex));
 312         when(janusGraphDao.updateVertex(graphVertex)).thenReturn(Either.left(graphVertex));
 313
 314         MapListRequirementDataDefinition mapListRequirementDataDefinition = new MapListRequirementDataDefinition();
 315         mapListRequirementDataDefinition.add(requirement.getCapability(), requirement);
 316         Map<String, MapListRequirementDataDefinition> mapOfRequirements = new HashMap<>();
 317         mapOfRequirements.put(requirement.getOwnerId(), mapListRequirementDataDefinition);
 318         GraphVertex childVertex = new GraphVertex();
 319         childVertex.setJson(mapOfRequirements);
 320         when(janusGraphDao.getChildVertex(graphVertex, EdgeLabelEnum.CALCULATED_REQUIREMENTS, JsonParseFlagEnum.ParseJson)).thenReturn(Either.left(childVertex));
 321
 322         JanusGraphVertex outVertex = Mockito.mock(JanusGraphVertex.class);
 323         Edge edge = Mockito.mock(Edge.class);
 324         when(edge.outVertex()).thenReturn(outVertex);
 325         Iterator<Edge> edgeIterator = new Iterator<Edge>() {
 326             private int counter = 0;
 327             @Override
 328             public boolean hasNext() {
 329                 return counter++ < 1;
 330             }
 331
 332             @Override
 333             public Edge next() {
 334                 return edge;
 335             }
 336         };
 337         String outId = (String) janusGraphDao
 338             .getProperty((JanusGraphVertex) outVertex, GraphPropertyEnum.UNIQUE_ID.getProperty());
 339         when(janusGraphDao.getProperty(outVertex, GraphPropertyEnum.UNIQUE_ID.getProperty())).thenReturn("uniqueId");
 340         when(janusGraphDao.updateVertex(childVertex)).thenReturn(Either.left(childVertex));
 341         JanusGraphVertex janusGraphVertex = Mockito.mock(JanusGraphVertex.class);
 342         childVertex.setVertex(janusGraphVertex);
 343         when(janusGraphVertex.edges(Direction.IN, EdgeLabelEnum.CALCULATED_REQUIREMENTS.name())).thenReturn(edgeIterator);
 344
 345         StorageOperationStatus result = operation.updateComponentInstanceRequirement(componentId, componentInstanceId, requirement);
 346         assertEquals(StorageOperationStatus.OK, result);
 347     }
 348
 349     @Test
 350     void test_addComponentInstanceOutput() {
 351         final NodeTemplateOperation testInstance = Mockito.spy(new NodeTemplateOperation());
 352         final Component component = new Resource();
 353         component.setUniqueId(COMPONENT_ID);
 354
 355         final String componentInstanceId = "requirementOwnerId";
 356
 357         final ComponentInstanceOutput instanceOutput = new ComponentInstanceOutput();
 358
 359         doReturn(StorageOperationStatus.OK).when((BaseOperation) testInstance)
 360             .addToscaDataDeepElementToToscaElement(eq(COMPONENT_ID), eq(EdgeLabelEnum.INST_OUTPUTS), eq(VertexTypeEnum.INST_OUTPUTS),
 361                 ArgumentMatchers.any(ComponentInstanceOutput.class), ArgumentMatchers.anyList(), eq(JsonPresentationFields.NAME));
 362
 363         final StorageOperationStatus result = testInstance.addComponentInstanceOutput(component, componentInstanceId, instanceOutput);
 364         assertNotNull(result);
 365         assertEquals(StorageOperationStatus.OK, result);
 366         verify((BaseOperation) testInstance, times(1))
 367             .addToscaDataDeepElementToToscaElement(eq(COMPONENT_ID), eq(EdgeLabelEnum.INST_OUTPUTS), eq(VertexTypeEnum.INST_OUTPUTS),
 368                 ArgumentMatchers.any(ComponentInstanceOutput.class), ArgumentMatchers.anyList(), eq(JsonPresentationFields.NAME));
 369     }
 370
 371     @Test
 372     void test_updateComponentInstanceAttributes() {
 373         final NodeTemplateOperation testInstance = Mockito.spy(new NodeTemplateOperation());
 374         final Component component = new Resource();
 375         component.setUniqueId(COMPONENT_ID);
 376
 377         final String componentInstanceId = "requirementOwnerId";
 378
 379         final ComponentInstanceAttribute instanceAttribute = new ComponentInstanceAttribute();
 380         final List<ComponentInstanceAttribute> attributes = new ArrayList<>();
 381         attributes.add(instanceAttribute);
 382
 383         doReturn(StorageOperationStatus.OK).when((BaseOperation) testInstance)
 384             .updateToscaDataDeepElementsOfToscaElement(eq(COMPONENT_ID), eq(EdgeLabelEnum.INST_ATTRIBUTES), eq(VertexTypeEnum.INST_ATTRIBUTES),
 385                 eq(attributes), ArgumentMatchers.anyList(), eq(JsonPresentationFields.NAME));
 386
 387         final StorageOperationStatus result = testInstance.updateComponentInstanceAttributes(component, componentInstanceId, attributes);
 388         assertNotNull(result);
 389         assertEquals(StorageOperationStatus.OK, result);
 390         verify((BaseOperation) testInstance, times(1))
 391             .updateToscaDataDeepElementsOfToscaElement(eq(COMPONENT_ID), eq(EdgeLabelEnum.INST_ATTRIBUTES), eq(VertexTypeEnum.INST_ATTRIBUTES),
 392                 eq(attributes), ArgumentMatchers.anyList(), eq(JsonPresentationFields.NAME));
 393     }
 394
 395     @Test
 396     void test_updateComponentInstanceAttribute() {
 397         final NodeTemplateOperation testInstance = Mockito.spy(new NodeTemplateOperation());
 398         final Component component = new Resource();
 399         component.setUniqueId(COMPONENT_ID);
 400
 401         final String componentInstanceId = "requirementOwnerId";
 402
 403         final ComponentInstanceAttribute instanceAttribute = new ComponentInstanceAttribute();
 404
 405         doReturn(StorageOperationStatus.OK).when((BaseOperation) testInstance)
 406             .updateToscaDataDeepElementOfToscaElement(eq(COMPONENT_ID), eq(EdgeLabelEnum.INST_ATTRIBUTES), eq(VertexTypeEnum.INST_ATTRIBUTES),
 407                 eq(instanceAttribute), ArgumentMatchers.anyList(), eq(JsonPresentationFields.NAME));
 408
 409         final StorageOperationStatus result = testInstance.updateComponentInstanceAttribute(component, componentInstanceId, instanceAttribute);
 410         assertNotNull(result);
 411         assertEquals(StorageOperationStatus.OK, result);
 412         verify((BaseOperation) testInstance, times(1))
 413             .updateToscaDataDeepElementOfToscaElement(eq(COMPONENT_ID), eq(EdgeLabelEnum.INST_ATTRIBUTES), eq(VertexTypeEnum.INST_ATTRIBUTES),
 414                 eq(instanceAttribute), ArgumentMatchers.anyList(), eq(JsonPresentationFields.NAME));
 415     }
 416
 417     @Test
 418     void test_updateComponentInstanceOutputs() {
 419         final NodeTemplateOperation testInstance = Mockito.spy(new NodeTemplateOperation());
 420         final Component component = new Resource();
 421         component.setUniqueId(COMPONENT_ID);
 422
 423         final String componentInstanceId = "requirementOwnerId";
 424
 425         List<ComponentInstanceOutput> componentInstanceOutputList = new ArrayList<>();
 426         ComponentInstanceOutput instanceOutput = new ComponentInstanceOutput();
 427         componentInstanceOutputList.add(instanceOutput);
 428
 429         doReturn(StorageOperationStatus.OK).when((BaseOperation) testInstance)
 430             .updateToscaDataDeepElementsOfToscaElement(eq(COMPONENT_ID), eq(EdgeLabelEnum.INST_OUTPUTS), eq(VertexTypeEnum.INST_OUTPUTS),
 431                 eq(componentInstanceOutputList), ArgumentMatchers.anyList(), eq(JsonPresentationFields.NAME));
 432
 433         final StorageOperationStatus result = testInstance.updateComponentInstanceOutputs(component, componentInstanceId, componentInstanceOutputList);
 434         assertNotNull(result);
 435         assertEquals(StorageOperationStatus.OK, result);
 436         verify((BaseOperation) testInstance, times(1))
 437             .updateToscaDataDeepElementsOfToscaElement(eq(COMPONENT_ID), eq(EdgeLabelEnum.INST_OUTPUTS), eq(VertexTypeEnum.INST_OUTPUTS),
 438                 eq(componentInstanceOutputList), ArgumentMatchers.anyList(), eq(JsonPresentationFields.NAME));
 439     }
 440
 441     private ComponentInstance createCompInstance() {
 442         ComponentInstance componentInstance = new ComponentInstance();
 443         String id = "id";
 444         componentInstance.setComponentUid(id);
 445         componentInstance.setUniqueId(id);
 446         componentInstance.setName(id);
 447         return componentInstance;
 448     }
 449
 450     private static void buildRequirementDataDefinition() {
 451         buildRequirement();
 452         fulfilledRequirement = new HashMap<>();
 453         MapListRequirementDataDefinition mapListRequirementDataDefinition = new MapListRequirementDataDefinition();
 454         mapListRequirementDataDefinition.add(requirement.getCapability(), requirement);
 455         fulfilledRequirement.put(FROM_INSTANCE_ID, mapListRequirementDataDefinition);
 456
 457     }
 458
 459     private static void buildRequirement() {
 460         requirement = new RequirementDataDefinition();
 461         requirement.setOwnerId(REQUIREMENT_OWNER_ID);
 462         requirement.setUniqueId(REQUIREMENT_UID);
 463         requirement.setName(REQUIREMENT_NAME);
 464         requirement.setRelationship(RELATIONSHIP_TYPE);
 465     }
 466
 467     private static void buildCapabiltyDataDefinition() {
 468         buildCapability();
 469         fulfilledCapability = new HashMap<>();
 470         MapListCapabilityDataDefinition mapListCapabiltyDataDefinition = new MapListCapabilityDataDefinition();
 471         mapListCapabiltyDataDefinition.add(capability.getType(), capability);
 472         fulfilledCapability.put(TO_INSTANCE_ID, mapListCapabiltyDataDefinition);
 473     }
 474
 475     private static void buildCapability() {
 476         capability = new CapabilityDataDefinition();
 477         capability.setOwnerId(CAPABILITY_OWNER_ID);
 478         capability.setUniqueId(CAPABILITY_UID);
 479         capability.setName(CAPABILITY_NAME);
 480     }
 481
 482     private static void buildRelation() {
 483
 484         relation = new RequirementCapabilityRelDef();
 485         CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
 486         RelationshipInfo relationInfo = new RelationshipInfo();
 487         relationInfo.setId(RELATION_ID);
 488         relationship.setRelation(relationInfo);
 489
 490         relation.setRelationships(Lists.newArrayList(relationship));
 491         relation.setToNode(TO_INSTANCE_ID);
 492         relation.setFromNode(FROM_INSTANCE_ID);
 493
 494         relationInfo.setCapabilityOwnerId(CAPABILITY_OWNER_ID);
 495         relationInfo.setCapabilityUid(CAPABILITY_UID);
 496         relationInfo.setCapability(CAPABILITY_NAME);
 497         relationInfo.setRequirementOwnerId(REQUIREMENT_OWNER_ID);
 498         relationInfo.setRequirementUid(REQUIREMENT_UID);
 499         relationInfo.setRequirement(REQUIREMENT_NAME);
 500         RelationshipImpl relationshipImpl  = new RelationshipImpl();
 501         relationshipImpl.setType(RELATIONSHIP_TYPE);
 502         relationInfo.setRelationships(relationshipImpl);
 503     }
 504
 505     private boolean isBelongingRequirement(RelationshipInfo relationshipInfo, RequirementDataDefinition req) {
 506         return  req.getRelationship().equals(relationshipInfo.getRelationship().getType()) &&
 507                 req.getName().equals(relationshipInfo.getRequirement()) &&
 508                 req.getUniqueId().equals(relationshipInfo.getRequirementUid()) &&
 509                 req.getOwnerId().equals(relationshipInfo.getRequirementOwnerId());
 510     }
 511
 512     private boolean isBelongingCapability(RelationshipInfo relationshipInfo, CapabilityDataDefinition cap) {
 513         return     cap.getName().equals(relationshipInfo.getCapability()) &&
 514                 cap.getUniqueId().equals(relationshipInfo.getCapabilityUid()) &&
 515                 cap.getOwnerId().equals(relationshipInfo.getCapabilityOwnerId());
 516     }
 517
 518 }