catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ComponentInterfaceOperationBusinessLogicTest.java

   1 /*
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2021 Nordix Foundation
   4  *  ================================================================================
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at
   8  *
   9  *        http://www.apache.org/licenses/LICENSE-2.0
  10  *  Unless required by applicable law or agreed to in writing, software
  11  *  distributed under the License is distributed on an "AS IS" BASIS,
  12  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *  See the License for the specific language governing permissions and
  14  *  limitations under the License.
  15  *
  16  *  SPDX-License-Identifier: Apache-2.0
  17  *  ============LICENSE_END=========================================================
  18  */
  19
  20 package org.openecomp.sdc.be.components.impl;
  21
  22 import static org.assertj.core.api.Assertions.assertThat;
  23 import static org.junit.jupiter.api.Assertions.assertTrue;
  24 import static org.junit.jupiter.api.Assertions.fail;
  25 import static org.mockito.ArgumentMatchers.any;
  26 import static org.mockito.Mockito.when;
  27
  28 import fj.data.Either;
  29 import java.util.ArrayList;
  30 import java.util.Arrays;
  31 import java.util.Collections;
  32 import java.util.HashMap;
  33 import java.util.List;
  34 import java.util.Map;
  35 import java.util.Optional;
  36 import java.util.UUID;
  37 import org.junit.jupiter.api.BeforeEach;
  38 import org.junit.jupiter.api.Test;
  39 import org.junit.jupiter.api.extension.ExtendWith;
  40 import org.mockito.InjectMocks;
  41 import org.mockito.Mock;
  42 import org.mockito.MockitoAnnotations;
  43 import org.mockito.junit.jupiter.MockitoExtension;
  44 import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
  45 import org.openecomp.sdc.be.components.validation.ComponentValidations;
  46 import org.openecomp.sdc.be.components.validation.UserValidations;
  47 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
  48 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
  49 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  50 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
  51 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  52 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
  53 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
  54 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  55 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  56 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  57 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
  58 import org.openecomp.sdc.be.impl.ComponentsUtils;
  59 import org.openecomp.sdc.be.model.ArtifactTypeDefinition;
  60 import org.openecomp.sdc.be.model.Component;
  61 import org.openecomp.sdc.be.model.ComponentInstance;
  62 import org.openecomp.sdc.be.model.ComponentInstanceInterface;
  63 import org.openecomp.sdc.be.model.ComponentParametersView;
  64 import org.openecomp.sdc.be.model.DataTypeDefinition;
  65 import org.openecomp.sdc.be.model.InterfaceDefinition;
  66 import org.openecomp.sdc.be.model.PropertyConstraint;
  67 import org.openecomp.sdc.be.model.PropertyDefinition;
  68 import org.openecomp.sdc.be.model.Service;
  69 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
  70 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  71 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  72 import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation;
  73 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
  74 import org.openecomp.sdc.be.model.tosca.constraints.ValidValuesConstraint;
  75 import org.openecomp.sdc.common.datastructure.Wrapper;
  76 import org.openecomp.sdc.exception.ResponseFormat;
  77
  78 @ExtendWith(MockitoExtension.class)
  79 class ComponentInterfaceOperationBusinessLogicTest extends BaseBusinessLogicMock {
  80
  81     @InjectMocks
  82     private ComponentInterfaceOperationBusinessLogic componentInterfaceOperationBusinessLogic;
  83
  84     @Mock
  85     private ToscaOperationFacade toscaOperationFacade;
  86     @Mock
  87     private GraphLockOperation graphLockOperation;
  88     @Mock
  89     private JanusGraphDao janusGraphDao;
  90     @Mock
  91     private JanusGraphGenericDao janusGraphGenericDao;
  92     @Mock
  93     private ComponentsUtils componentsUtils;
  94     @Mock
  95     private UserValidations userValidations;
  96     @Mock
  97     private ComponentValidations componentValidations;
  98     @Mock
  99     private PropertyBusinessLogic propertyBusinessLogic;
 100     @Mock
 101     private ApplicationDataTypeCache applicationDataTypeCache;
 102     @Mock
 103     private ArtifactTypeBusinessLogic artifactTypeBusinessLogic;
 104
 105     private Component component;
 106     private ComponentInstance componentInstance;
 107     private ComponentParametersView componentFilter;
 108
 109     @BeforeEach
 110     public void init() {
 111         MockitoAnnotations.openMocks(this);
 112         componentInterfaceOperationBusinessLogic =
 113             new ComponentInterfaceOperationBusinessLogic(elementDao, groupOperation, groupInstanceOperation,
 114                 groupTypeOperation, interfaceOperation, interfaceLifecycleTypeOperation, artifactToscaOperation,
 115                 componentValidations, propertyBusinessLogic, artifactTypeBusinessLogic);
 116         componentInterfaceOperationBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
 117         componentInterfaceOperationBusinessLogic.setGraphLockOperation(graphLockOperation);
 118         componentInterfaceOperationBusinessLogic.setComponentsUtils(componentsUtils);
 119         componentInterfaceOperationBusinessLogic.setUserValidations(userValidations);
 120         componentInterfaceOperationBusinessLogic.setJanusGraphGenericDao(janusGraphGenericDao);
 121         componentInterfaceOperationBusinessLogic.setJanusGraphDao(janusGraphDao);
 122         componentInterfaceOperationBusinessLogic.setApplicationDataTypeCache(applicationDataTypeCache);
 123         initComponentData();
 124     }
 125
 126     @Test
 127     void updateComponentInstanceInterfaceOperationTest() throws BusinessLogicException {
 128         final String componentId = component.getUniqueId();
 129         final String componentInstanceId = componentInstance.getUniqueId();
 130         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 131         interfaceDefinition.setUniqueId(UUID.randomUUID().toString());
 132         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 133         final Map<String, OperationDataDefinition> operations = new HashMap<>();
 134         final OperationDataDefinition operationDataDefinition = new OperationDataDefinition();
 135         operationDataDefinition.setUniqueId(UUID.randomUUID().toString());
 136         operationDataDefinition.setName("myOperationName");
 137         final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 138         artifactDataDefinition.setArtifactName("EO Implementation info");
 139         operationDataDefinition.setImplementation(artifactDataDefinition);
 140         operations.put("configure", operationDataDefinition);
 141         interfaceDefinition.setOperations(operations );
 142
 143         final ComponentInstanceInterface componentInstanceInterface =
 144             new ComponentInstanceInterface("interfaceId", interfaceDefinition);
 145         Map<String, List<ComponentInstanceInterface>> componentInstancesInterfacesMap = new HashMap<>();
 146         componentInstancesInterfacesMap.put(componentInstanceId, Collections.singletonList(componentInstanceInterface));
 147         component.setComponentInstancesInterfaces(componentInstancesInterfacesMap);
 148         componentInstance.setInterfaces(
 149             (Map<String, Object>) new HashMap<>().put(componentInstanceId, interfaceDefinition));
 150         component.setComponentInstances(Collections.singletonList(componentInstance));
 151
 152         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
 153         when(componentValidations.getComponentInstance(component, componentInstanceId))
 154             .thenReturn(Optional.of(componentInstance));
 155         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
 156             .thenReturn(StorageOperationStatus.OK);
 157         when(toscaOperationFacade.updateComponentInstanceInterfaces(component, componentInstanceId))
 158             .thenReturn(StorageOperationStatus.OK);
 159         when(toscaOperationFacade
 160             .updateComponentInstanceMetadataOfTopologyTemplate(any(Service.class), any(ComponentParametersView.class)))
 161             .thenReturn(Either.left(component));
 162         when(janusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
 163         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
 164             .thenReturn(StorageOperationStatus.OK);
 165         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
 166
 167         final Optional<ComponentInstance> result = componentInterfaceOperationBusinessLogic
 168             .updateComponentInstanceInterfaceOperation(componentId, componentInstanceId, interfaceDefinition,
 169                 ComponentTypeEnum.SERVICE, new Wrapper<>(), true);
 170         assertThat(result).isPresent();
 171     }
 172
 173     @Test
 174     void valueForInputFailsConstraintsValidation() throws BusinessLogicException {
 175         final String inputType = "myType";
 176         final String componentId = component.getUniqueId();
 177         final String componentInstanceId = componentInstance.getUniqueId();
 178         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 179         interfaceDefinition.setUniqueId(UUID.randomUUID().toString());
 180         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 181         final Map<String, OperationDataDefinition> operations = new HashMap<>();
 182         final OperationDataDefinition operationDataDefinition = new OperationDataDefinition();
 183         operationDataDefinition.setUniqueId(UUID.randomUUID().toString());
 184         operationDataDefinition.setName("myOperationName");
 185         final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 186         final ListDataDefinition<OperationInputDefinition> inputsDefinitionListData = new ListDataDefinition<>();
 187         OperationInputDefinition input1 = new OperationInputDefinition();
 188         input1.setName("input_1");
 189         input1.setType(inputType);
 190         input1.setValue("{\"input_range\": \"invalid\"}");
 191         inputsDefinitionListData.add(input1);
 192         artifactDataDefinition.setArtifactName("EO Implementation info");
 193         operationDataDefinition.setImplementation(artifactDataDefinition);
 194         operationDataDefinition.setInputs(inputsDefinitionListData);
 195         operations.put("configure", operationDataDefinition);
 196         interfaceDefinition.setOperations(operations );
 197
 198         DataTypeDefinition myType = new DataTypeDefinition();
 199         myType.setName(inputType);
 200         PropertyDefinition input_range = new PropertyDefinition();
 201         input_range.setName("input_range");
 202         input_range.setType("string");
 203         PropertyConstraint constraint1 = new ValidValuesConstraint(Arrays.asList("value1", "value2", "value3"));
 204         input_range.setConstraints(List.of(constraint1));
 205         myType.setProperties(List.of(input_range));
 206         Map<String, DataTypeDefinition> dataTypes = Collections.singletonMap(myType.getName(), myType);
 207         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
 208
 209         final ComponentInstanceInterface componentInstanceInterface =
 210             new ComponentInstanceInterface("interfaceId", interfaceDefinition);
 211         Map<String, List<ComponentInstanceInterface>> componentInstancesInterfacesMap = new HashMap<>();
 212         componentInstancesInterfacesMap.put(componentInstanceId, Collections.singletonList(componentInstanceInterface));
 213         component.setComponentInstancesInterfaces(componentInstancesInterfacesMap);
 214         componentInstance.setInterfaces(
 215             (Map<String, Object>) new HashMap<>().put(componentInstanceId, interfaceDefinition));
 216         component.setComponentInstances(Collections.singletonList(componentInstance));
 217
 218         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
 219         when(componentValidations.getComponentInstance(component, componentInstanceId))
 220             .thenReturn(Optional.of(componentInstance));
 221         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(dataTypes));
 222
 223         final Optional<ComponentInstance> result = componentInterfaceOperationBusinessLogic
 224             .updateComponentInstanceInterfaceOperation(componentId, componentInstanceId, interfaceDefinition,
 225                 ComponentTypeEnum.SERVICE, errorWrapper, false);
 226         assertThat(result).isNotPresent();
 227         assertTrue(errorWrapper.getInnerElement().getStatus() == 400);
 228         assertTrue(errorWrapper.getInnerElement().getRequestError().getRequestError().getServiceException().getText()
 229             .contains("Error: Invalid property values provided"));
 230     }
 231
 232     @Test
 233     void valueForInputSucceedsConstraintsValidation() throws BusinessLogicException {
 234         final String inputType = "myType";
 235         final String componentId = component.getUniqueId();
 236         final String componentInstanceId = componentInstance.getUniqueId();
 237         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 238         interfaceDefinition.setUniqueId(UUID.randomUUID().toString());
 239         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 240         final Map<String, OperationDataDefinition> operations = new HashMap<>();
 241         final OperationDataDefinition operationDataDefinition = new OperationDataDefinition();
 242         operationDataDefinition.setUniqueId(UUID.randomUUID().toString());
 243         operationDataDefinition.setName("myOperationName");
 244         final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 245         final ListDataDefinition<OperationInputDefinition> inputsDefinitionListData = new ListDataDefinition<>();
 246         OperationInputDefinition input1 = new OperationInputDefinition();
 247         input1.setName("input_1");
 248         input1.setType(inputType);
 249         input1.setValue("{\"input_range\": \"value1\"}");
 250         inputsDefinitionListData.add(input1);
 251         artifactDataDefinition.setArtifactName("EO Implementation info");
 252         operationDataDefinition.setImplementation(artifactDataDefinition);
 253         operationDataDefinition.setInputs(inputsDefinitionListData);
 254         operations.put("configure", operationDataDefinition);
 255         interfaceDefinition.setOperations(operations );
 256
 257         DataTypeDefinition myType = new DataTypeDefinition();
 258         myType.setName(inputType);
 259         PropertyDefinition input_range = new PropertyDefinition();
 260         input_range.setName("input_range");
 261         input_range.setType("string");
 262         PropertyConstraint constraint1 = new ValidValuesConstraint(Arrays.asList("value1", "value2", "value3"));
 263         input_range.setConstraints(List.of(constraint1));
 264         myType.setProperties(List.of(input_range));
 265         Map<String, DataTypeDefinition> dataTypes = Collections.singletonMap(myType.getName(), myType);
 266         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
 267
 268         final ComponentInstanceInterface componentInstanceInterface =
 269             new ComponentInstanceInterface("interfaceId", interfaceDefinition);
 270         Map<String, List<ComponentInstanceInterface>> componentInstancesInterfacesMap = new HashMap<>();
 271         componentInstancesInterfacesMap.put(componentInstanceId, Collections.singletonList(componentInstanceInterface));
 272         component.setComponentInstancesInterfaces(componentInstancesInterfacesMap);
 273         componentInstance.setInterfaces(
 274             (Map<String, Object>) new HashMap<>().put(componentInstanceId, interfaceDefinition));
 275         component.setComponentInstances(Collections.singletonList(componentInstance));
 276
 277         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
 278         when(componentValidations.getComponentInstance(component, componentInstanceId))
 279             .thenReturn(Optional.of(componentInstance));
 280         when(toscaOperationFacade.updateComponentInstanceInterfaces(component, componentInstanceId))
 281             .thenReturn(StorageOperationStatus.OK);
 282         when(toscaOperationFacade
 283             .updateComponentInstanceMetadataOfTopologyTemplate(any(Service.class), any(ComponentParametersView.class)))
 284             .thenReturn(Either.left(component));
 285         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(dataTypes));
 286
 287         final Optional<ComponentInstance> result = componentInterfaceOperationBusinessLogic
 288             .updateComponentInstanceInterfaceOperation(componentId, componentInstanceId, interfaceDefinition,
 289                 ComponentTypeEnum.SERVICE, errorWrapper, false);
 290         assertThat(result).isPresent();
 291     }
 292
 293     @Test
 294     void valueForArtifactInputFailsConstraintsValidation() throws BusinessLogicException {
 295         final String inputType = "myType";
 296         final String artifactType = "artifactType";
 297         final String componentId = component.getUniqueId();
 298         final String componentInstanceId = componentInstance.getUniqueId();
 299         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 300         interfaceDefinition.setUniqueId(UUID.randomUUID().toString());
 301         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 302         final Map<String, OperationDataDefinition> operations = new HashMap<>();
 303         final OperationDataDefinition operationDataDefinition = new OperationDataDefinition();
 304         operationDataDefinition.setUniqueId(UUID.randomUUID().toString());
 305         operationDataDefinition.setName("myOperationName");
 306         final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 307
 308         artifactDataDefinition.setArtifactName("EO Implementation info");
 309         artifactDataDefinition.setArtifactType(artifactType);
 310         PropertyDataDefinition propertyDataDefinition = new PropertyDataDefinition();
 311         propertyDataDefinition.setName("propertyWithRestrictedValues");
 312         propertyDataDefinition.setType(inputType);
 313         propertyDataDefinition.setValue("{\"propertyWithRestrictedValues\": \"invalid\"}");
 314         artifactDataDefinition.addProperty(propertyDataDefinition);
 315
 316         operationDataDefinition.setImplementation(artifactDataDefinition);
 317         operations.put("configure", operationDataDefinition);
 318         interfaceDefinition.setOperations(operations );
 319
 320         final DataTypeDefinition myType = new DataTypeDefinition();
 321         final ArtifactTypeDefinition artifactTypeDefinitionFromCache = new ArtifactTypeDefinition();
 322         artifactTypeDefinitionFromCache.setName(UniqueIdBuilder.buildArtifactTypeUid(null, artifactType));
 323         myType.setName(inputType);
 324         PropertyDefinition propertyWithRestrictedValues = new PropertyDefinition();
 325         propertyWithRestrictedValues.setName("propertyWithRestrictedValues");
 326         propertyWithRestrictedValues.setType("string");
 327         PropertyConstraint constraint1 = new ValidValuesConstraint(Arrays.asList("value1", "value2", "value3"));
 328         propertyWithRestrictedValues.setConstraints(List.of(constraint1));
 329         artifactTypeDefinitionFromCache.setProperties(List.of(propertyWithRestrictedValues));
 330         myType.setProperties(List.of(propertyWithRestrictedValues));
 331         Map<String, DataTypeDefinition> dataTypes = Collections.singletonMap(myType.getName(), myType);
 332         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
 333
 334         final ComponentInstanceInterface componentInstanceInterface =
 335             new ComponentInstanceInterface("interfaceId", interfaceDefinition);
 336         Map<String, List<ComponentInstanceInterface>> componentInstancesInterfacesMap = new HashMap<>();
 337         componentInstancesInterfacesMap.put(componentInstanceId, Collections.singletonList(componentInstanceInterface));
 338         component.setComponentInstancesInterfaces(componentInstancesInterfacesMap);
 339         componentInstance.setInterfaces(
 340             (Map<String, Object>) new HashMap<>().put(componentInstanceId, interfaceDefinition));
 341         component.setComponentInstances(Collections.singletonList(componentInstance));
 342
 343         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
 344         when(componentValidations.getComponentInstance(component, componentInstanceId))
 345             .thenReturn(Optional.of(componentInstance));
 346         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(dataTypes));
 347         when(artifactTypeBusinessLogic.getArtifactTypeByUid(UniqueIdBuilder.buildArtifactTypeUid(
 348             null, artifactType))).thenReturn(artifactTypeDefinitionFromCache);
 349
 350         final Optional<ComponentInstance> result = componentInterfaceOperationBusinessLogic
 351             .updateComponentInstanceInterfaceOperation(componentId, componentInstanceId, interfaceDefinition,
 352                 ComponentTypeEnum.SERVICE, errorWrapper, false);
 353         assertThat(result).isNotPresent();
 354         assertTrue(errorWrapper.getInnerElement().getStatus() == 400);
 355         assertTrue(errorWrapper.getInnerElement().getRequestError().getRequestError().getServiceException().getText()
 356             .contains("Error: Invalid property values provided"));
 357     }
 358
 359     @Test
 360     void valueForArtifactInputSucceedsConstraintsValidation() throws BusinessLogicException {
 361         final String inputType = "myType";
 362         final String artifactType = "artifactType";
 363         final String componentId = component.getUniqueId();
 364         final String componentInstanceId = componentInstance.getUniqueId();
 365         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 366         interfaceDefinition.setUniqueId(UUID.randomUUID().toString());
 367         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 368         final Map<String, OperationDataDefinition> operations = new HashMap<>();
 369         final OperationDataDefinition operationDataDefinition = new OperationDataDefinition();
 370         operationDataDefinition.setUniqueId(UUID.randomUUID().toString());
 371         operationDataDefinition.setName("myOperationName");
 372         final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 373
 374         artifactDataDefinition.setArtifactName("EO Implementation info");
 375         artifactDataDefinition.setArtifactType(artifactType);
 376         PropertyDataDefinition propertyDataDefinition = new PropertyDataDefinition();
 377         propertyDataDefinition.setName("input_range");
 378         propertyDataDefinition.setType(inputType);
 379         propertyDataDefinition.setValue("{\"input_range\": \"value2\"}");
 380         artifactDataDefinition.addProperty(propertyDataDefinition);
 381
 382         operationDataDefinition.setImplementation(artifactDataDefinition);
 383         operations.put("configure", operationDataDefinition);
 384         interfaceDefinition.setOperations(operations );
 385
 386         DataTypeDefinition myType = new DataTypeDefinition();
 387         final ArtifactTypeDefinition artifactTypeDefinitionFromCache = new ArtifactTypeDefinition();
 388         artifactTypeDefinitionFromCache.setName(UniqueIdBuilder.buildArtifactTypeUid(null, artifactType));
 389         myType.setName(inputType);
 390         PropertyDefinition input_range = new PropertyDefinition();
 391         input_range.setName("input_range");
 392         input_range.setType("string");
 393         PropertyConstraint constraint1 = new ValidValuesConstraint(Arrays.asList("value1", "value2", "value3"));
 394         input_range.setConstraints(List.of(constraint1));
 395         artifactTypeDefinitionFromCache.setProperties(List.of(input_range));
 396         myType.setProperties(List.of(input_range));
 397         Map<String, DataTypeDefinition> dataTypes = Collections.singletonMap(myType.getName(), myType);
 398         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
 399
 400         final ComponentInstanceInterface componentInstanceInterface =
 401             new ComponentInstanceInterface("interfaceId", interfaceDefinition);
 402         Map<String, List<ComponentInstanceInterface>> componentInstancesInterfacesMap = new HashMap<>();
 403         componentInstancesInterfacesMap.put(componentInstanceId, Collections.singletonList(componentInstanceInterface));
 404         component.setComponentInstancesInterfaces(componentInstancesInterfacesMap);
 405         componentInstance.setInterfaces(
 406             (Map<String, Object>) new HashMap<>().put(componentInstanceId, interfaceDefinition));
 407         component.setComponentInstances(Collections.singletonList(componentInstance));
 408
 409         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
 410         when(componentValidations.getComponentInstance(component, componentInstanceId))
 411             .thenReturn(Optional.of(componentInstance));
 412         when(toscaOperationFacade.updateComponentInstanceInterfaces(component, componentInstanceId))
 413             .thenReturn(StorageOperationStatus.OK);
 414         when(toscaOperationFacade
 415             .updateComponentInstanceMetadataOfTopologyTemplate(any(Service.class), any(ComponentParametersView.class)))
 416             .thenReturn(Either.left(component));
 417         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(dataTypes));
 418         when(artifactTypeBusinessLogic.getArtifactTypeByUid(UniqueIdBuilder.buildArtifactTypeUid(
 419             null, artifactType))).thenReturn(artifactTypeDefinitionFromCache);
 420
 421         final Optional<ComponentInstance> result = componentInterfaceOperationBusinessLogic
 422             .updateComponentInstanceInterfaceOperation(componentId, componentInstanceId, interfaceDefinition,
 423                 ComponentTypeEnum.SERVICE, errorWrapper, false);
 424         assertThat(result).isPresent();
 425     }
 426
 427     @Test
 428     void createComponentInstanceInterfaceOperationTest() throws BusinessLogicException {
 429         final String componentId = component.getUniqueId();
 430         final String componentInstanceId = componentInstance.getUniqueId();
 431         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 432         interfaceDefinition.setUniqueId(UUID.randomUUID().toString());
 433         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 434         final Map<String, OperationDataDefinition> operations = new HashMap<>();
 435         final OperationDataDefinition operationDataDefinition = new OperationDataDefinition();
 436         operationDataDefinition.setUniqueId(UUID.randomUUID().toString());
 437         operationDataDefinition.setName("myOperationName");
 438         final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 439         artifactDataDefinition.setArtifactName("EO Implementation info");
 440         operationDataDefinition.setImplementation(artifactDataDefinition);
 441         operations.put("configure", operationDataDefinition);
 442         interfaceDefinition.setOperations(operations );
 443
 444         Map<String, List<ComponentInstanceInterface>> componentInstancesInterfacesMap = new HashMap<>();
 445         componentInstancesInterfacesMap.put(componentInstanceId, new ArrayList<>());
 446         componentInstance.setInterfaces(
 447             (Map<String, Object>) new HashMap<>().put(componentInstanceId, interfaceDefinition));
 448         component.setComponentInstances(Collections.singletonList(componentInstance));
 449
 450         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
 451         when(componentValidations.getComponentInstance(component, componentInstanceId))
 452             .thenReturn(Optional.of(componentInstance));
 453         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
 454             .thenReturn(StorageOperationStatus.OK);
 455         when(toscaOperationFacade.updateComponentInstanceInterfaces(component, componentInstanceId))
 456             .thenReturn(StorageOperationStatus.OK);
 457         when(janusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
 458         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
 459             .thenReturn(StorageOperationStatus.OK);
 460
 461         final Optional<ComponentInstance> result = componentInterfaceOperationBusinessLogic
 462             .createComponentInstanceInterfaceOperation(componentId, componentInstanceId, interfaceDefinition,
 463                 ComponentTypeEnum.SERVICE, new Wrapper<>(), true);
 464         assertThat(result).isPresent();
 465     }
 466
 467     @Test
 468     void createComponentInstanceInterfaceOperationTestUpdateFail() throws BusinessLogicException {
 469         final String componentId = component.getUniqueId();
 470         final String componentInstanceId = componentInstance.getUniqueId();
 471         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 472         interfaceDefinition.setUniqueId(UUID.randomUUID().toString());
 473         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 474         final Map<String, OperationDataDefinition> operations = new HashMap<>();
 475         final OperationDataDefinition operationDataDefinition = new OperationDataDefinition();
 476         operationDataDefinition.setUniqueId(UUID.randomUUID().toString());
 477         operationDataDefinition.setName("myOperationName");
 478         final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 479         artifactDataDefinition.setArtifactName("EO Implementation info");
 480         operationDataDefinition.setImplementation(artifactDataDefinition);
 481         operations.put("configure", operationDataDefinition);
 482         interfaceDefinition.setOperations(operations );
 483
 484         Map<String, List<ComponentInstanceInterface>> componentInstancesInterfacesMap = new HashMap<>();
 485         componentInstancesInterfacesMap.put(componentInstanceId, new ArrayList<>());
 486         componentInstance.setInterfaces(
 487             (Map<String, Object>) new HashMap<>().put(componentInstanceId, interfaceDefinition));
 488         component.setComponentInstances(Collections.singletonList(componentInstance));
 489
 490         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
 491         when(componentValidations.getComponentInstance(component, componentInstanceId))
 492             .thenReturn(Optional.of(componentInstance));
 493         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
 494             .thenReturn(StorageOperationStatus.OK);
 495         when(toscaOperationFacade.updateComponentInstanceInterfaces(component, componentInstanceId))
 496             .thenReturn(StorageOperationStatus.GENERAL_ERROR);
 497         when(janusGraphDao.rollback()).thenReturn(JanusGraphOperationStatus.OK);
 498         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
 499             .thenReturn(StorageOperationStatus.OK);
 500
 501         final Optional<ComponentInstance> result = componentInterfaceOperationBusinessLogic
 502             .createComponentInstanceInterfaceOperation(componentId, componentInstanceId, interfaceDefinition,
 503                 ComponentTypeEnum.SERVICE, new Wrapper<>(), true);
 504         assertThat(result).isEmpty();
 505     }
 506
 507     @Test
 508     void createComponentInstanceInterfaceOperationTestNoInstances() throws BusinessLogicException {
 509         final String componentId = component.getUniqueId();
 510         final String componentInstanceId = componentInstance.getUniqueId();
 511         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 512         interfaceDefinition.setUniqueId(UUID.randomUUID().toString());
 513         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 514
 515         component.setComponentInstances(Collections.singletonList(componentInstance));
 516
 517         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
 518
 519         final Optional<ComponentInstance> result = componentInterfaceOperationBusinessLogic
 520             .createComponentInstanceInterfaceOperation(componentId, componentInstanceId, interfaceDefinition,
 521                 ComponentTypeEnum.SERVICE, new Wrapper<>(), true);
 522         assertThat(result).isEmpty();
 523     }
 524
 525     @Test
 526     void createComponentInstanceInterfaceOperationTestNoOperations() throws BusinessLogicException {
 527         final String componentId = component.getUniqueId();
 528         final String componentInstanceId = componentInstance.getUniqueId();
 529         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 530         interfaceDefinition.setUniqueId(UUID.randomUUID().toString());
 531         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 532
 533         Map<String, List<ComponentInstanceInterface>> componentInstancesInterfacesMap = new HashMap<>();
 534         componentInstancesInterfacesMap.put(componentInstanceId, new ArrayList<>());
 535         componentInstance.setInterfaces(
 536             (Map<String, Object>) new HashMap<>().put(componentInstanceId, interfaceDefinition));
 537         component.setComponentInstances(Collections.singletonList(componentInstance));
 538
 539         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
 540         when(componentValidations.getComponentInstance(component, componentInstanceId))
 541             .thenReturn(Optional.of(componentInstance));
 542
 543         final Optional<ComponentInstance> result = componentInterfaceOperationBusinessLogic
 544             .createComponentInstanceInterfaceOperation(componentId, componentInstanceId, interfaceDefinition,
 545                 ComponentTypeEnum.SERVICE, new Wrapper<>(), true);
 546         assertThat(result).isEmpty();
 547     }
 548
 549     private void initComponentData() {
 550         try {
 551             component = new Service();
 552             component.setName("MyTestService");
 553             component.setUniqueId("dac65869-dfb4-40d2-aa20-084324659ec1");
 554
 555             componentInstance = new ComponentInstance();
 556             componentInstance.setUniqueId("dac65869-dfb4-40d2-aa20-084324659ec1.resource0");
 557             componentInstance.setOriginType(OriginTypeEnum.VFC);
 558             componentInstance.setName("My VFC Instance");
 559
 560             componentFilter = new ComponentParametersView();
 561             componentFilter.disableAll();
 562             componentFilter.setIgnoreUsers(false);
 563             componentFilter.setIgnoreComponentInstances(false);
 564             componentFilter.setIgnoreInterfaces(false);
 565             componentFilter.setIgnoreComponentInstancesInterfaces(false);
 566
 567         } catch (final Exception e) {
 568             fail(e.getMessage());
 569         }
 570     }
 571 }