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.Arrays;
  30 import java.util.Collections;
  31 import java.util.HashMap;
  32 import java.util.List;
  33 import java.util.Map;
  34 import java.util.Optional;
  35 import java.util.UUID;
  36 import org.junit.jupiter.api.BeforeEach;
  37 import org.junit.jupiter.api.Test;
  38 import org.junit.jupiter.api.extension.ExtendWith;
  39 import org.mockito.InjectMocks;
  40 import org.mockito.Mock;
  41 import org.mockito.MockitoAnnotations;
  42 import org.mockito.junit.jupiter.MockitoExtension;
  43 import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
  44 import org.openecomp.sdc.be.components.validation.ComponentValidations;
  45 import org.openecomp.sdc.be.components.validation.UserValidations;
  46 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
  47 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
  48 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  49 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
  50 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  51 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
  52 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
  53 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  54 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  55 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  56 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
  57 import org.openecomp.sdc.be.impl.ComponentsUtils;
  58 import org.openecomp.sdc.be.model.ArtifactTypeDefinition;
  59 import org.openecomp.sdc.be.model.Component;
  60 import org.openecomp.sdc.be.model.ComponentInstance;
  61 import org.openecomp.sdc.be.model.ComponentInstanceInterface;
  62 import org.openecomp.sdc.be.model.ComponentParametersView;
  63 import org.openecomp.sdc.be.model.DataTypeDefinition;
  64 import org.openecomp.sdc.be.model.InterfaceDefinition;
  65 import org.openecomp.sdc.be.model.PropertyConstraint;
  66 import org.openecomp.sdc.be.model.PropertyDefinition;
  67 import org.openecomp.sdc.be.model.Service;
  68 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
  69 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  70 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  71 import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation;
  72 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
  73 import org.openecomp.sdc.be.model.tosca.constraints.ValidValuesConstraint;
  74 import org.openecomp.sdc.common.datastructure.Wrapper;
  75 import org.openecomp.sdc.exception.ResponseFormat;
  76
  77 @ExtendWith(MockitoExtension.class)
  78 class ComponentInterfaceOperationBusinessLogicTest extends BaseBusinessLogicMock {
  79
  80     @InjectMocks
  81     private ComponentInterfaceOperationBusinessLogic componentInterfaceOperationBusinessLogic;
  82
  83     @Mock
  84     private ToscaOperationFacade toscaOperationFacade;
  85     @Mock
  86     private GraphLockOperation graphLockOperation;
  87     @Mock
  88     private JanusGraphDao janusGraphDao;
  89     @Mock
  90     private JanusGraphGenericDao janusGraphGenericDao;
  91     @Mock
  92     private ComponentsUtils componentsUtils;
  93     @Mock
  94     private UserValidations userValidations;
  95     @Mock
  96     private ComponentValidations componentValidations;
  97     @Mock
  98     private PropertyBusinessLogic propertyBusinessLogic;
  99     @Mock
 100     private ApplicationDataTypeCache applicationDataTypeCache;
 101     @Mock
 102     private ArtifactTypeBusinessLogic artifactTypeBusinessLogic;
 103
 104     private Component component;
 105     private ComponentInstance componentInstance;
 106     private ComponentParametersView componentFilter;
 107
 108     @BeforeEach
 109     public void init() {
 110         MockitoAnnotations.openMocks(this);
 111         componentInterfaceOperationBusinessLogic =
 112             new ComponentInterfaceOperationBusinessLogic(elementDao, groupOperation, groupInstanceOperation,
 113                 groupTypeOperation, interfaceOperation, interfaceLifecycleTypeOperation, artifactToscaOperation,
 114                 componentValidations, propertyBusinessLogic, artifactTypeBusinessLogic);
 115         componentInterfaceOperationBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
 116         componentInterfaceOperationBusinessLogic.setGraphLockOperation(graphLockOperation);
 117         componentInterfaceOperationBusinessLogic.setComponentsUtils(componentsUtils);
 118         componentInterfaceOperationBusinessLogic.setUserValidations(userValidations);
 119         componentInterfaceOperationBusinessLogic.setJanusGraphGenericDao(janusGraphGenericDao);
 120         componentInterfaceOperationBusinessLogic.setJanusGraphDao(janusGraphDao);
 121         componentInterfaceOperationBusinessLogic.setApplicationDataTypeCache(applicationDataTypeCache);
 122         initComponentData();
 123     }
 124
 125     @Test
 126     void updateComponentInstanceInterfaceOperationTest() throws BusinessLogicException {
 127         final String componentId = component.getUniqueId();
 128         final String componentInstanceId = componentInstance.getUniqueId();
 129         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 130         interfaceDefinition.setUniqueId(UUID.randomUUID().toString());
 131         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 132         final Map<String, OperationDataDefinition> operations = new HashMap<>();
 133         final OperationDataDefinition operationDataDefinition = new OperationDataDefinition();
 134         operationDataDefinition.setUniqueId(UUID.randomUUID().toString());
 135         final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 136         artifactDataDefinition.setArtifactName("EO Implementation info");
 137         operationDataDefinition.setImplementation(artifactDataDefinition);
 138         operations.put("configure", operationDataDefinition);
 139         interfaceDefinition.setOperations(operations );
 140
 141         final ComponentInstanceInterface componentInstanceInterface =
 142             new ComponentInstanceInterface("interfaceId", interfaceDefinition);
 143         Map<String, List<ComponentInstanceInterface>> componentInstancesInterfacesMap = new HashMap<>();
 144         componentInstancesInterfacesMap.put(componentInstanceId, Collections.singletonList(componentInstanceInterface));
 145         component.setComponentInstancesInterfaces(componentInstancesInterfacesMap);
 146         componentInstance.setInterfaces(
 147             (Map<String, Object>) new HashMap<>().put(componentInstanceId, interfaceDefinition));
 148         component.setComponentInstances(Collections.singletonList(componentInstance));
 149
 150         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
 151         when(componentValidations.getComponentInstance(component, componentInstanceId))
 152             .thenReturn(Optional.of(componentInstance));
 153         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
 154             .thenReturn(StorageOperationStatus.OK);
 155         when(toscaOperationFacade.updateComponentInstanceInterfaces(component, componentInstanceId))
 156             .thenReturn(StorageOperationStatus.OK);
 157         when(toscaOperationFacade
 158             .updateComponentInstanceMetadataOfTopologyTemplate(any(Service.class), any(ComponentParametersView.class)))
 159             .thenReturn(Either.left(component));
 160         when(janusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
 161         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
 162             .thenReturn(StorageOperationStatus.OK);
 163         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
 164
 165         final Optional<ComponentInstance> result = componentInterfaceOperationBusinessLogic
 166             .updateComponentInstanceInterfaceOperation(componentId, componentInstanceId, interfaceDefinition,
 167                 ComponentTypeEnum.SERVICE, new Wrapper<>(), true);
 168         assertThat(result).isPresent();
 169     }
 170
 171     @Test
 172     void valueForInputFailsConstraintsValidation() throws BusinessLogicException {
 173         final String inputType = "myType";
 174         final String componentId = component.getUniqueId();
 175         final String componentInstanceId = componentInstance.getUniqueId();
 176         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 177         interfaceDefinition.setUniqueId(UUID.randomUUID().toString());
 178         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 179         final Map<String, OperationDataDefinition> operations = new HashMap<>();
 180         final OperationDataDefinition operationDataDefinition = new OperationDataDefinition();
 181         operationDataDefinition.setUniqueId(UUID.randomUUID().toString());
 182         final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 183         final ListDataDefinition<OperationInputDefinition> inputsDefinitionListData = new ListDataDefinition<>();
 184         OperationInputDefinition input1 = new OperationInputDefinition();
 185         input1.setName("input_1");
 186         input1.setType(inputType);
 187         input1.setValue("{\"input_range\": \"invalid\"}");
 188         inputsDefinitionListData.add(input1);
 189         artifactDataDefinition.setArtifactName("EO Implementation info");
 190         operationDataDefinition.setImplementation(artifactDataDefinition);
 191         operationDataDefinition.setInputs(inputsDefinitionListData);
 192         operations.put("configure", operationDataDefinition);
 193         interfaceDefinition.setOperations(operations );
 194
 195         DataTypeDefinition myType = new DataTypeDefinition();
 196         myType.setName(inputType);
 197         PropertyDefinition input_range = new PropertyDefinition();
 198         input_range.setName("input_range");
 199         input_range.setType("string");
 200         PropertyConstraint constraint1 = new ValidValuesConstraint(Arrays.asList("value1", "value2", "value3"));
 201         input_range.setConstraints(List.of(constraint1));
 202         myType.setProperties(List.of(input_range));
 203         Map<String, DataTypeDefinition> dataTypes = Collections.singletonMap(myType.getName(), myType);
 204         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
 205
 206         final ComponentInstanceInterface componentInstanceInterface =
 207             new ComponentInstanceInterface("interfaceId", interfaceDefinition);
 208         Map<String, List<ComponentInstanceInterface>> componentInstancesInterfacesMap = new HashMap<>();
 209         componentInstancesInterfacesMap.put(componentInstanceId, Collections.singletonList(componentInstanceInterface));
 210         component.setComponentInstancesInterfaces(componentInstancesInterfacesMap);
 211         componentInstance.setInterfaces(
 212             (Map<String, Object>) new HashMap<>().put(componentInstanceId, interfaceDefinition));
 213         component.setComponentInstances(Collections.singletonList(componentInstance));
 214
 215         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
 216         when(componentValidations.getComponentInstance(component, componentInstanceId))
 217             .thenReturn(Optional.of(componentInstance));
 218         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(dataTypes));
 219
 220         final Optional<ComponentInstance> result = componentInterfaceOperationBusinessLogic
 221             .updateComponentInstanceInterfaceOperation(componentId, componentInstanceId, interfaceDefinition,
 222                 ComponentTypeEnum.SERVICE, errorWrapper, false);
 223         assertThat(result).isNotPresent();
 224         assertTrue(errorWrapper.getInnerElement().getStatus() == 400);
 225         assertTrue(errorWrapper.getInnerElement().getRequestError().getRequestError().getServiceException().getText()
 226             .contains("Error: Invalid property values provided"));
 227     }
 228
 229     @Test
 230     void valueForInputSucceedsConstraintsValidation() throws BusinessLogicException {
 231         final String inputType = "myType";
 232         final String componentId = component.getUniqueId();
 233         final String componentInstanceId = componentInstance.getUniqueId();
 234         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 235         interfaceDefinition.setUniqueId(UUID.randomUUID().toString());
 236         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 237         final Map<String, OperationDataDefinition> operations = new HashMap<>();
 238         final OperationDataDefinition operationDataDefinition = new OperationDataDefinition();
 239         operationDataDefinition.setUniqueId(UUID.randomUUID().toString());
 240         final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 241         final ListDataDefinition<OperationInputDefinition> inputsDefinitionListData = new ListDataDefinition<>();
 242         OperationInputDefinition input1 = new OperationInputDefinition();
 243         input1.setName("input_1");
 244         input1.setType(inputType);
 245         input1.setValue("{\"input_range\": \"value1\"}");
 246         inputsDefinitionListData.add(input1);
 247         artifactDataDefinition.setArtifactName("EO Implementation info");
 248         operationDataDefinition.setImplementation(artifactDataDefinition);
 249         operationDataDefinition.setInputs(inputsDefinitionListData);
 250         operations.put("configure", operationDataDefinition);
 251         interfaceDefinition.setOperations(operations );
 252
 253         DataTypeDefinition myType = new DataTypeDefinition();
 254         myType.setName(inputType);
 255         PropertyDefinition input_range = new PropertyDefinition();
 256         input_range.setName("input_range");
 257         input_range.setType("string");
 258         PropertyConstraint constraint1 = new ValidValuesConstraint(Arrays.asList("value1", "value2", "value3"));
 259         input_range.setConstraints(List.of(constraint1));
 260         myType.setProperties(List.of(input_range));
 261         Map<String, DataTypeDefinition> dataTypes = Collections.singletonMap(myType.getName(), myType);
 262         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
 263
 264         final ComponentInstanceInterface componentInstanceInterface =
 265             new ComponentInstanceInterface("interfaceId", interfaceDefinition);
 266         Map<String, List<ComponentInstanceInterface>> componentInstancesInterfacesMap = new HashMap<>();
 267         componentInstancesInterfacesMap.put(componentInstanceId, Collections.singletonList(componentInstanceInterface));
 268         component.setComponentInstancesInterfaces(componentInstancesInterfacesMap);
 269         componentInstance.setInterfaces(
 270             (Map<String, Object>) new HashMap<>().put(componentInstanceId, interfaceDefinition));
 271         component.setComponentInstances(Collections.singletonList(componentInstance));
 272
 273         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
 274         when(componentValidations.getComponentInstance(component, componentInstanceId))
 275             .thenReturn(Optional.of(componentInstance));
 276         when(toscaOperationFacade.updateComponentInstanceInterfaces(component, componentInstanceId))
 277             .thenReturn(StorageOperationStatus.OK);
 278         when(toscaOperationFacade
 279             .updateComponentInstanceMetadataOfTopologyTemplate(any(Service.class), any(ComponentParametersView.class)))
 280             .thenReturn(Either.left(component));
 281         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(dataTypes));
 282
 283         final Optional<ComponentInstance> result = componentInterfaceOperationBusinessLogic
 284             .updateComponentInstanceInterfaceOperation(componentId, componentInstanceId, interfaceDefinition,
 285                 ComponentTypeEnum.SERVICE, errorWrapper, false);
 286         assertThat(result).isPresent();
 287     }
 288
 289     @Test
 290     void valueForArtifactInputFailsConstraintsValidation() throws BusinessLogicException {
 291         final String inputType = "myType";
 292         final String artifactType = "artifactType";
 293         final String componentId = component.getUniqueId();
 294         final String componentInstanceId = componentInstance.getUniqueId();
 295         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 296         interfaceDefinition.setUniqueId(UUID.randomUUID().toString());
 297         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 298         final Map<String, OperationDataDefinition> operations = new HashMap<>();
 299         final OperationDataDefinition operationDataDefinition = new OperationDataDefinition();
 300         operationDataDefinition.setUniqueId(UUID.randomUUID().toString());
 301         final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 302
 303         artifactDataDefinition.setArtifactName("EO Implementation info");
 304         artifactDataDefinition.setArtifactType(artifactType);
 305         PropertyDataDefinition propertyDataDefinition = new PropertyDataDefinition();
 306         propertyDataDefinition.setName("propertyWithRestrictedValues");
 307         propertyDataDefinition.setType(inputType);
 308         propertyDataDefinition.setValue("{\"propertyWithRestrictedValues\": \"invalid\"}");
 309         artifactDataDefinition.addProperty(propertyDataDefinition);
 310
 311         operationDataDefinition.setImplementation(artifactDataDefinition);
 312         operations.put("configure", operationDataDefinition);
 313         interfaceDefinition.setOperations(operations );
 314
 315         final DataTypeDefinition myType = new DataTypeDefinition();
 316         final ArtifactTypeDefinition artifactTypeDefinitionFromCache = new ArtifactTypeDefinition();
 317         artifactTypeDefinitionFromCache.setName(UniqueIdBuilder.buildArtifactTypeUid(null, artifactType));
 318         myType.setName(inputType);
 319         PropertyDefinition propertyWithRestrictedValues = new PropertyDefinition();
 320         propertyWithRestrictedValues.setName("propertyWithRestrictedValues");
 321         propertyWithRestrictedValues.setType("string");
 322         PropertyConstraint constraint1 = new ValidValuesConstraint(Arrays.asList("value1", "value2", "value3"));
 323         propertyWithRestrictedValues.setConstraints(List.of(constraint1));
 324         artifactTypeDefinitionFromCache.setProperties(List.of(propertyWithRestrictedValues));
 325         myType.setProperties(List.of(propertyWithRestrictedValues));
 326         Map<String, DataTypeDefinition> dataTypes = Collections.singletonMap(myType.getName(), myType);
 327         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
 328
 329         final ComponentInstanceInterface componentInstanceInterface =
 330             new ComponentInstanceInterface("interfaceId", interfaceDefinition);
 331         Map<String, List<ComponentInstanceInterface>> componentInstancesInterfacesMap = new HashMap<>();
 332         componentInstancesInterfacesMap.put(componentInstanceId, Collections.singletonList(componentInstanceInterface));
 333         component.setComponentInstancesInterfaces(componentInstancesInterfacesMap);
 334         componentInstance.setInterfaces(
 335             (Map<String, Object>) new HashMap<>().put(componentInstanceId, interfaceDefinition));
 336         component.setComponentInstances(Collections.singletonList(componentInstance));
 337
 338         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
 339         when(componentValidations.getComponentInstance(component, componentInstanceId))
 340             .thenReturn(Optional.of(componentInstance));
 341         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(dataTypes));
 342         when(artifactTypeBusinessLogic.getArtifactTypeByUid(UniqueIdBuilder.buildArtifactTypeUid(
 343             null, artifactType))).thenReturn(artifactTypeDefinitionFromCache);
 344
 345         final Optional<ComponentInstance> result = componentInterfaceOperationBusinessLogic
 346             .updateComponentInstanceInterfaceOperation(componentId, componentInstanceId, interfaceDefinition,
 347                 ComponentTypeEnum.SERVICE, errorWrapper, false);
 348         assertThat(result).isNotPresent();
 349         assertTrue(errorWrapper.getInnerElement().getStatus() == 400);
 350         assertTrue(errorWrapper.getInnerElement().getRequestError().getRequestError().getServiceException().getText()
 351             .contains("Error: Invalid property values provided"));
 352     }
 353
 354     @Test
 355     void valueForArtifactInputSucceedsConstraintsValidation() throws BusinessLogicException {
 356         final String inputType = "myType";
 357         final String artifactType = "artifactType";
 358         final String componentId = component.getUniqueId();
 359         final String componentInstanceId = componentInstance.getUniqueId();
 360         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 361         interfaceDefinition.setUniqueId(UUID.randomUUID().toString());
 362         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 363         final Map<String, OperationDataDefinition> operations = new HashMap<>();
 364         final OperationDataDefinition operationDataDefinition = new OperationDataDefinition();
 365         operationDataDefinition.setUniqueId(UUID.randomUUID().toString());
 366         final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 367
 368         artifactDataDefinition.setArtifactName("EO Implementation info");
 369         artifactDataDefinition.setArtifactType(artifactType);
 370         PropertyDataDefinition propertyDataDefinition = new PropertyDataDefinition();
 371         propertyDataDefinition.setName("input_range");
 372         propertyDataDefinition.setType(inputType);
 373         propertyDataDefinition.setValue("{\"input_range\": \"value2\"}");
 374         artifactDataDefinition.addProperty(propertyDataDefinition);
 375
 376         operationDataDefinition.setImplementation(artifactDataDefinition);
 377         operations.put("configure", operationDataDefinition);
 378         interfaceDefinition.setOperations(operations );
 379
 380         DataTypeDefinition myType = new DataTypeDefinition();
 381         final ArtifactTypeDefinition artifactTypeDefinitionFromCache = new ArtifactTypeDefinition();
 382         artifactTypeDefinitionFromCache.setName(UniqueIdBuilder.buildArtifactTypeUid(null, artifactType));
 383         myType.setName(inputType);
 384         PropertyDefinition input_range = new PropertyDefinition();
 385         input_range.setName("input_range");
 386         input_range.setType("string");
 387         PropertyConstraint constraint1 = new ValidValuesConstraint(Arrays.asList("value1", "value2", "value3"));
 388         input_range.setConstraints(List.of(constraint1));
 389         artifactTypeDefinitionFromCache.setProperties(List.of(input_range));
 390         myType.setProperties(List.of(input_range));
 391         Map<String, DataTypeDefinition> dataTypes = Collections.singletonMap(myType.getName(), myType);
 392         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
 393
 394         final ComponentInstanceInterface componentInstanceInterface =
 395             new ComponentInstanceInterface("interfaceId", interfaceDefinition);
 396         Map<String, List<ComponentInstanceInterface>> componentInstancesInterfacesMap = new HashMap<>();
 397         componentInstancesInterfacesMap.put(componentInstanceId, Collections.singletonList(componentInstanceInterface));
 398         component.setComponentInstancesInterfaces(componentInstancesInterfacesMap);
 399         componentInstance.setInterfaces(
 400             (Map<String, Object>) new HashMap<>().put(componentInstanceId, interfaceDefinition));
 401         component.setComponentInstances(Collections.singletonList(componentInstance));
 402
 403         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
 404         when(componentValidations.getComponentInstance(component, componentInstanceId))
 405             .thenReturn(Optional.of(componentInstance));
 406         when(toscaOperationFacade.updateComponentInstanceInterfaces(component, componentInstanceId))
 407             .thenReturn(StorageOperationStatus.OK);
 408         when(toscaOperationFacade
 409             .updateComponentInstanceMetadataOfTopologyTemplate(any(Service.class), any(ComponentParametersView.class)))
 410             .thenReturn(Either.left(component));
 411         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(dataTypes));
 412         when(artifactTypeBusinessLogic.getArtifactTypeByUid(UniqueIdBuilder.buildArtifactTypeUid(
 413             null, artifactType))).thenReturn(artifactTypeDefinitionFromCache);
 414
 415         final Optional<ComponentInstance> result = componentInterfaceOperationBusinessLogic
 416             .updateComponentInstanceInterfaceOperation(componentId, componentInstanceId, interfaceDefinition,
 417                 ComponentTypeEnum.SERVICE, errorWrapper, false);
 418         assertThat(result).isPresent();
 419     }
 420
 421     private void initComponentData() {
 422         try {
 423             component = new Service();
 424             component.setName("MyTestService");
 425             component.setUniqueId("dac65869-dfb4-40d2-aa20-084324659ec1");
 426
 427             componentInstance = new ComponentInstance();
 428             componentInstance.setUniqueId("dac65869-dfb4-40d2-aa20-084324659ec1.resource0");
 429             componentInstance.setOriginType(OriginTypeEnum.VFC);
 430             componentInstance.setName("My VFC Instance");
 431
 432             componentFilter = new ComponentParametersView();
 433             componentFilter.disableAll();
 434             componentFilter.setIgnoreUsers(false);
 435             componentFilter.setIgnoreComponentInstances(false);
 436             componentFilter.setIgnoreInterfaces(false);
 437             componentFilter.setIgnoreComponentInstancesInterfaces(false);
 438
 439         } catch (final Exception e) {
 440             fail(e.getMessage());
 441         }
 442     }
 443 }