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