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         final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 137         artifactDataDefinition.setArtifactName("EO Implementation info");
 138         operationDataDefinition.setImplementation(artifactDataDefinition);
 139         operations.put("configure", operationDataDefinition);
 140         interfaceDefinition.setOperations(operations );
 141
 142         final ComponentInstanceInterface componentInstanceInterface =
 143             new ComponentInstanceInterface("interfaceId", interfaceDefinition);
 144         Map<String, List<ComponentInstanceInterface>> componentInstancesInterfacesMap = new HashMap<>();
 145         componentInstancesInterfacesMap.put(componentInstanceId, Collections.singletonList(componentInstanceInterface));
 146         component.setComponentInstancesInterfaces(componentInstancesInterfacesMap);
 147         componentInstance.setInterfaces(
 148             (Map<String, Object>) new HashMap<>().put(componentInstanceId, interfaceDefinition));
 149         component.setComponentInstances(Collections.singletonList(componentInstance));
 150
 151         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
 152         when(componentValidations.getComponentInstance(component, componentInstanceId))
 153             .thenReturn(Optional.of(componentInstance));
 154         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
 155             .thenReturn(StorageOperationStatus.OK);
 156         when(toscaOperationFacade.updateComponentInstanceInterfaces(component, componentInstanceId))
 157             .thenReturn(StorageOperationStatus.OK);
 158         when(toscaOperationFacade
 159             .updateComponentInstanceMetadataOfTopologyTemplate(any(Service.class), any(ComponentParametersView.class)))
 160             .thenReturn(Either.left(component));
 161         when(janusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
 162         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
 163             .thenReturn(StorageOperationStatus.OK);
 164         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
 165
 166         final Optional<ComponentInstance> result = componentInterfaceOperationBusinessLogic
 167             .updateComponentInstanceInterfaceOperation(componentId, componentInstanceId, interfaceDefinition,
 168                 ComponentTypeEnum.SERVICE, new Wrapper<>(), true);
 169         assertThat(result).isPresent();
 170     }
 171
 172     @Test
 173     void valueForInputFailsConstraintsValidation() throws BusinessLogicException {
 174         final String inputType = "myType";
 175         final String componentId = component.getUniqueId();
 176         final String componentInstanceId = componentInstance.getUniqueId();
 177         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 178         interfaceDefinition.setUniqueId(UUID.randomUUID().toString());
 179         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 180         final Map<String, OperationDataDefinition> operations = new HashMap<>();
 181         final OperationDataDefinition operationDataDefinition = new OperationDataDefinition();
 182         operationDataDefinition.setUniqueId(UUID.randomUUID().toString());
 183         final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 184         final ListDataDefinition<OperationInputDefinition> inputsDefinitionListData = new ListDataDefinition<>();
 185         OperationInputDefinition input1 = new OperationInputDefinition();
 186         input1.setName("input_1");
 187         input1.setType(inputType);
 188         input1.setValue("{\"input_range\": \"invalid\"}");
 189         inputsDefinitionListData.add(input1);
 190         artifactDataDefinition.setArtifactName("EO Implementation info");
 191         operationDataDefinition.setImplementation(artifactDataDefinition);
 192         operationDataDefinition.setInputs(inputsDefinitionListData);
 193         operations.put("configure", operationDataDefinition);
 194         interfaceDefinition.setOperations(operations );
 195
 196         DataTypeDefinition myType = new DataTypeDefinition();
 197         myType.setName(inputType);
 198         PropertyDefinition input_range = new PropertyDefinition();
 199         input_range.setName("input_range");
 200         input_range.setType("string");
 201         PropertyConstraint constraint1 = new ValidValuesConstraint(Arrays.asList("value1", "value2", "value3"));
 202         input_range.setConstraints(List.of(constraint1));
 203         myType.setProperties(List.of(input_range));
 204         Map<String, DataTypeDefinition> dataTypes = Collections.singletonMap(myType.getName(), myType);
 205         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
 206
 207         final ComponentInstanceInterface componentInstanceInterface =
 208             new ComponentInstanceInterface("interfaceId", interfaceDefinition);
 209         Map<String, List<ComponentInstanceInterface>> componentInstancesInterfacesMap = new HashMap<>();
 210         componentInstancesInterfacesMap.put(componentInstanceId, Collections.singletonList(componentInstanceInterface));
 211         component.setComponentInstancesInterfaces(componentInstancesInterfacesMap);
 212         componentInstance.setInterfaces(
 213             (Map<String, Object>) new HashMap<>().put(componentInstanceId, interfaceDefinition));
 214         component.setComponentInstances(Collections.singletonList(componentInstance));
 215
 216         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
 217         when(componentValidations.getComponentInstance(component, componentInstanceId))
 218             .thenReturn(Optional.of(componentInstance));
 219         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(dataTypes));
 220
 221         final Optional<ComponentInstance> result = componentInterfaceOperationBusinessLogic
 222             .updateComponentInstanceInterfaceOperation(componentId, componentInstanceId, interfaceDefinition,
 223                 ComponentTypeEnum.SERVICE, errorWrapper, false);
 224         assertThat(result).isNotPresent();
 225         assertTrue(errorWrapper.getInnerElement().getStatus() == 400);
 226         assertTrue(errorWrapper.getInnerElement().getRequestError().getRequestError().getServiceException().getText()
 227             .contains("Error: Invalid property values provided"));
 228     }
 229
 230     @Test
 231     void valueForInputSucceedsConstraintsValidation() throws BusinessLogicException {
 232         final String inputType = "myType";
 233         final String componentId = component.getUniqueId();
 234         final String componentInstanceId = componentInstance.getUniqueId();
 235         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 236         interfaceDefinition.setUniqueId(UUID.randomUUID().toString());
 237         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 238         final Map<String, OperationDataDefinition> operations = new HashMap<>();
 239         final OperationDataDefinition operationDataDefinition = new OperationDataDefinition();
 240         operationDataDefinition.setUniqueId(UUID.randomUUID().toString());
 241         final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 242         final ListDataDefinition<OperationInputDefinition> inputsDefinitionListData = new ListDataDefinition<>();
 243         OperationInputDefinition input1 = new OperationInputDefinition();
 244         input1.setName("input_1");
 245         input1.setType(inputType);
 246         input1.setValue("{\"input_range\": \"value1\"}");
 247         inputsDefinitionListData.add(input1);
 248         artifactDataDefinition.setArtifactName("EO Implementation info");
 249         operationDataDefinition.setImplementation(artifactDataDefinition);
 250         operationDataDefinition.setInputs(inputsDefinitionListData);
 251         operations.put("configure", operationDataDefinition);
 252         interfaceDefinition.setOperations(operations );
 253
 254         DataTypeDefinition myType = new DataTypeDefinition();
 255         myType.setName(inputType);
 256         PropertyDefinition input_range = new PropertyDefinition();
 257         input_range.setName("input_range");
 258         input_range.setType("string");
 259         PropertyConstraint constraint1 = new ValidValuesConstraint(Arrays.asList("value1", "value2", "value3"));
 260         input_range.setConstraints(List.of(constraint1));
 261         myType.setProperties(List.of(input_range));
 262         Map<String, DataTypeDefinition> dataTypes = Collections.singletonMap(myType.getName(), myType);
 263         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
 264
 265         final ComponentInstanceInterface componentInstanceInterface =
 266             new ComponentInstanceInterface("interfaceId", interfaceDefinition);
 267         Map<String, List<ComponentInstanceInterface>> componentInstancesInterfacesMap = new HashMap<>();
 268         componentInstancesInterfacesMap.put(componentInstanceId, Collections.singletonList(componentInstanceInterface));
 269         component.setComponentInstancesInterfaces(componentInstancesInterfacesMap);
 270         componentInstance.setInterfaces(
 271             (Map<String, Object>) new HashMap<>().put(componentInstanceId, interfaceDefinition));
 272         component.setComponentInstances(Collections.singletonList(componentInstance));
 273
 274         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
 275         when(componentValidations.getComponentInstance(component, componentInstanceId))
 276             .thenReturn(Optional.of(componentInstance));
 277         when(toscaOperationFacade.updateComponentInstanceInterfaces(component, componentInstanceId))
 278             .thenReturn(StorageOperationStatus.OK);
 279         when(toscaOperationFacade
 280             .updateComponentInstanceMetadataOfTopologyTemplate(any(Service.class), any(ComponentParametersView.class)))
 281             .thenReturn(Either.left(component));
 282         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(dataTypes));
 283
 284         final Optional<ComponentInstance> result = componentInterfaceOperationBusinessLogic
 285             .updateComponentInstanceInterfaceOperation(componentId, componentInstanceId, interfaceDefinition,
 286                 ComponentTypeEnum.SERVICE, errorWrapper, false);
 287         assertThat(result).isPresent();
 288     }
 289
 290     @Test
 291     void valueForArtifactInputFailsConstraintsValidation() throws BusinessLogicException {
 292         final String inputType = "myType";
 293         final String artifactType = "artifactType";
 294         final String componentId = component.getUniqueId();
 295         final String componentInstanceId = componentInstance.getUniqueId();
 296         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 297         interfaceDefinition.setUniqueId(UUID.randomUUID().toString());
 298         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 299         final Map<String, OperationDataDefinition> operations = new HashMap<>();
 300         final OperationDataDefinition operationDataDefinition = new OperationDataDefinition();
 301         operationDataDefinition.setUniqueId(UUID.randomUUID().toString());
 302         final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 303
 304         artifactDataDefinition.setArtifactName("EO Implementation info");
 305         artifactDataDefinition.setArtifactType(artifactType);
 306         PropertyDataDefinition propertyDataDefinition = new PropertyDataDefinition();
 307         propertyDataDefinition.setName("propertyWithRestrictedValues");
 308         propertyDataDefinition.setType(inputType);
 309         propertyDataDefinition.setValue("{\"propertyWithRestrictedValues\": \"invalid\"}");
 310         artifactDataDefinition.addProperty(propertyDataDefinition);
 311
 312         operationDataDefinition.setImplementation(artifactDataDefinition);
 313         operations.put("configure", operationDataDefinition);
 314         interfaceDefinition.setOperations(operations );
 315
 316         final DataTypeDefinition myType = new DataTypeDefinition();
 317         final ArtifactTypeDefinition artifactTypeDefinitionFromCache = new ArtifactTypeDefinition();
 318         artifactTypeDefinitionFromCache.setName(UniqueIdBuilder.buildArtifactTypeUid(null, artifactType));
 319         myType.setName(inputType);
 320         PropertyDefinition propertyWithRestrictedValues = new PropertyDefinition();
 321         propertyWithRestrictedValues.setName("propertyWithRestrictedValues");
 322         propertyWithRestrictedValues.setType("string");
 323         PropertyConstraint constraint1 = new ValidValuesConstraint(Arrays.asList("value1", "value2", "value3"));
 324         propertyWithRestrictedValues.setConstraints(List.of(constraint1));
 325         artifactTypeDefinitionFromCache.setProperties(List.of(propertyWithRestrictedValues));
 326         myType.setProperties(List.of(propertyWithRestrictedValues));
 327         Map<String, DataTypeDefinition> dataTypes = Collections.singletonMap(myType.getName(), myType);
 328         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
 329
 330         final ComponentInstanceInterface componentInstanceInterface =
 331             new ComponentInstanceInterface("interfaceId", interfaceDefinition);
 332         Map<String, List<ComponentInstanceInterface>> componentInstancesInterfacesMap = new HashMap<>();
 333         componentInstancesInterfacesMap.put(componentInstanceId, Collections.singletonList(componentInstanceInterface));
 334         component.setComponentInstancesInterfaces(componentInstancesInterfacesMap);
 335         componentInstance.setInterfaces(
 336             (Map<String, Object>) new HashMap<>().put(componentInstanceId, interfaceDefinition));
 337         component.setComponentInstances(Collections.singletonList(componentInstance));
 338
 339         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
 340         when(componentValidations.getComponentInstance(component, componentInstanceId))
 341             .thenReturn(Optional.of(componentInstance));
 342         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(dataTypes));
 343         when(artifactTypeBusinessLogic.getArtifactTypeByUid(UniqueIdBuilder.buildArtifactTypeUid(
 344             null, artifactType))).thenReturn(artifactTypeDefinitionFromCache);
 345
 346         final Optional<ComponentInstance> result = componentInterfaceOperationBusinessLogic
 347             .updateComponentInstanceInterfaceOperation(componentId, componentInstanceId, interfaceDefinition,
 348                 ComponentTypeEnum.SERVICE, errorWrapper, false);
 349         assertThat(result).isNotPresent();
 350         assertTrue(errorWrapper.getInnerElement().getStatus() == 400);
 351         assertTrue(errorWrapper.getInnerElement().getRequestError().getRequestError().getServiceException().getText()
 352             .contains("Error: Invalid property values provided"));
 353     }
 354
 355     @Test
 356     void valueForArtifactInputSucceedsConstraintsValidation() throws BusinessLogicException {
 357         final String inputType = "myType";
 358         final String artifactType = "artifactType";
 359         final String componentId = component.getUniqueId();
 360         final String componentInstanceId = componentInstance.getUniqueId();
 361         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 362         interfaceDefinition.setUniqueId(UUID.randomUUID().toString());
 363         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 364         final Map<String, OperationDataDefinition> operations = new HashMap<>();
 365         final OperationDataDefinition operationDataDefinition = new OperationDataDefinition();
 366         operationDataDefinition.setUniqueId(UUID.randomUUID().toString());
 367         final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 368
 369         artifactDataDefinition.setArtifactName("EO Implementation info");
 370         artifactDataDefinition.setArtifactType(artifactType);
 371         PropertyDataDefinition propertyDataDefinition = new PropertyDataDefinition();
 372         propertyDataDefinition.setName("input_range");
 373         propertyDataDefinition.setType(inputType);
 374         propertyDataDefinition.setValue("{\"input_range\": \"value2\"}");
 375         artifactDataDefinition.addProperty(propertyDataDefinition);
 376
 377         operationDataDefinition.setImplementation(artifactDataDefinition);
 378         operations.put("configure", operationDataDefinition);
 379         interfaceDefinition.setOperations(operations );
 380
 381         DataTypeDefinition myType = new DataTypeDefinition();
 382         final ArtifactTypeDefinition artifactTypeDefinitionFromCache = new ArtifactTypeDefinition();
 383         artifactTypeDefinitionFromCache.setName(UniqueIdBuilder.buildArtifactTypeUid(null, artifactType));
 384         myType.setName(inputType);
 385         PropertyDefinition input_range = new PropertyDefinition();
 386         input_range.setName("input_range");
 387         input_range.setType("string");
 388         PropertyConstraint constraint1 = new ValidValuesConstraint(Arrays.asList("value1", "value2", "value3"));
 389         input_range.setConstraints(List.of(constraint1));
 390         artifactTypeDefinitionFromCache.setProperties(List.of(input_range));
 391         myType.setProperties(List.of(input_range));
 392         Map<String, DataTypeDefinition> dataTypes = Collections.singletonMap(myType.getName(), myType);
 393         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
 394
 395         final ComponentInstanceInterface componentInstanceInterface =
 396             new ComponentInstanceInterface("interfaceId", interfaceDefinition);
 397         Map<String, List<ComponentInstanceInterface>> componentInstancesInterfacesMap = new HashMap<>();
 398         componentInstancesInterfacesMap.put(componentInstanceId, Collections.singletonList(componentInstanceInterface));
 399         component.setComponentInstancesInterfaces(componentInstancesInterfacesMap);
 400         componentInstance.setInterfaces(
 401             (Map<String, Object>) new HashMap<>().put(componentInstanceId, interfaceDefinition));
 402         component.setComponentInstances(Collections.singletonList(componentInstance));
 403
 404         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
 405         when(componentValidations.getComponentInstance(component, componentInstanceId))
 406             .thenReturn(Optional.of(componentInstance));
 407         when(toscaOperationFacade.updateComponentInstanceInterfaces(component, componentInstanceId))
 408             .thenReturn(StorageOperationStatus.OK);
 409         when(toscaOperationFacade
 410             .updateComponentInstanceMetadataOfTopologyTemplate(any(Service.class), any(ComponentParametersView.class)))
 411             .thenReturn(Either.left(component));
 412         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(dataTypes));
 413         when(artifactTypeBusinessLogic.getArtifactTypeByUid(UniqueIdBuilder.buildArtifactTypeUid(
 414             null, artifactType))).thenReturn(artifactTypeDefinitionFromCache);
 415
 416         final Optional<ComponentInstance> result = componentInterfaceOperationBusinessLogic
 417             .updateComponentInstanceInterfaceOperation(componentId, componentInstanceId, interfaceDefinition,
 418                 ComponentTypeEnum.SERVICE, errorWrapper, false);
 419         assertThat(result).isPresent();
 420     }
 421
 422     @Test
 423     void createComponentInstanceInterfaceOperationTest() throws BusinessLogicException {
 424         final String componentId = component.getUniqueId();
 425         final String componentInstanceId = componentInstance.getUniqueId();
 426         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 427         interfaceDefinition.setUniqueId(UUID.randomUUID().toString());
 428         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 429         final Map<String, OperationDataDefinition> operations = new HashMap<>();
 430         final OperationDataDefinition operationDataDefinition = new OperationDataDefinition();
 431         operationDataDefinition.setUniqueId(UUID.randomUUID().toString());
 432         final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 433         artifactDataDefinition.setArtifactName("EO Implementation info");
 434         operationDataDefinition.setImplementation(artifactDataDefinition);
 435         operations.put("configure", operationDataDefinition);
 436         interfaceDefinition.setOperations(operations );
 437
 438         Map<String, List<ComponentInstanceInterface>> componentInstancesInterfacesMap = new HashMap<>();
 439         componentInstancesInterfacesMap.put(componentInstanceId, new ArrayList<>());
 440         componentInstance.setInterfaces(
 441             (Map<String, Object>) new HashMap<>().put(componentInstanceId, interfaceDefinition));
 442         component.setComponentInstances(Collections.singletonList(componentInstance));
 443
 444         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
 445         when(componentValidations.getComponentInstance(component, componentInstanceId))
 446             .thenReturn(Optional.of(componentInstance));
 447         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
 448             .thenReturn(StorageOperationStatus.OK);
 449         when(toscaOperationFacade.updateComponentInstanceInterfaces(component, componentInstanceId))
 450             .thenReturn(StorageOperationStatus.OK);
 451         when(janusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
 452         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
 453             .thenReturn(StorageOperationStatus.OK);
 454
 455         final Optional<ComponentInstance> result = componentInterfaceOperationBusinessLogic
 456             .createComponentInstanceInterfaceOperation(componentId, componentInstanceId, interfaceDefinition,
 457                 ComponentTypeEnum.SERVICE, new Wrapper<>(), true);
 458         assertThat(result).isPresent();
 459     }
 460
 461     @Test
 462     void createComponentInstanceInterfaceOperationTestUpdateFail() throws BusinessLogicException {
 463         final String componentId = component.getUniqueId();
 464         final String componentInstanceId = componentInstance.getUniqueId();
 465         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 466         interfaceDefinition.setUniqueId(UUID.randomUUID().toString());
 467         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 468         final Map<String, OperationDataDefinition> operations = new HashMap<>();
 469         final OperationDataDefinition operationDataDefinition = new OperationDataDefinition();
 470         operationDataDefinition.setUniqueId(UUID.randomUUID().toString());
 471         final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 472         artifactDataDefinition.setArtifactName("EO Implementation info");
 473         operationDataDefinition.setImplementation(artifactDataDefinition);
 474         operations.put("configure", operationDataDefinition);
 475         interfaceDefinition.setOperations(operations );
 476
 477         Map<String, List<ComponentInstanceInterface>> componentInstancesInterfacesMap = new HashMap<>();
 478         componentInstancesInterfacesMap.put(componentInstanceId, new ArrayList<>());
 479         componentInstance.setInterfaces(
 480             (Map<String, Object>) new HashMap<>().put(componentInstanceId, interfaceDefinition));
 481         component.setComponentInstances(Collections.singletonList(componentInstance));
 482
 483         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
 484         when(componentValidations.getComponentInstance(component, componentInstanceId))
 485             .thenReturn(Optional.of(componentInstance));
 486         when(graphLockOperation.lockComponent(componentId, NodeTypeEnum.Service))
 487             .thenReturn(StorageOperationStatus.OK);
 488         when(toscaOperationFacade.updateComponentInstanceInterfaces(component, componentInstanceId))
 489             .thenReturn(StorageOperationStatus.GENERAL_ERROR);
 490         when(janusGraphDao.rollback()).thenReturn(JanusGraphOperationStatus.OK);
 491         when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Service))
 492             .thenReturn(StorageOperationStatus.OK);
 493
 494         final Optional<ComponentInstance> result = componentInterfaceOperationBusinessLogic
 495             .createComponentInstanceInterfaceOperation(componentId, componentInstanceId, interfaceDefinition,
 496                 ComponentTypeEnum.SERVICE, new Wrapper<>(), true);
 497         assertThat(result).isEmpty();
 498     }
 499
 500     @Test
 501     void createComponentInstanceInterfaceOperationTestNoInstances() throws BusinessLogicException {
 502         final String componentId = component.getUniqueId();
 503         final String componentInstanceId = componentInstance.getUniqueId();
 504         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 505         interfaceDefinition.setUniqueId(UUID.randomUUID().toString());
 506         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 507
 508         component.setComponentInstances(Collections.singletonList(componentInstance));
 509
 510         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
 511
 512         final Optional<ComponentInstance> result = componentInterfaceOperationBusinessLogic
 513             .createComponentInstanceInterfaceOperation(componentId, componentInstanceId, interfaceDefinition,
 514                 ComponentTypeEnum.SERVICE, new Wrapper<>(), true);
 515         assertThat(result).isEmpty();
 516     }
 517
 518     @Test
 519     void createComponentInstanceInterfaceOperationTestNoOperations() throws BusinessLogicException {
 520         final String componentId = component.getUniqueId();
 521         final String componentInstanceId = componentInstance.getUniqueId();
 522         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 523         interfaceDefinition.setUniqueId(UUID.randomUUID().toString());
 524         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 525
 526         Map<String, List<ComponentInstanceInterface>> componentInstancesInterfacesMap = new HashMap<>();
 527         componentInstancesInterfacesMap.put(componentInstanceId, new ArrayList<>());
 528         componentInstance.setInterfaces(
 529             (Map<String, Object>) new HashMap<>().put(componentInstanceId, interfaceDefinition));
 530         component.setComponentInstances(Collections.singletonList(componentInstance));
 531
 532         when(toscaOperationFacade.getToscaElement(componentId)).thenReturn(Either.left(component));
 533         when(componentValidations.getComponentInstance(component, componentInstanceId))
 534             .thenReturn(Optional.of(componentInstance));
 535
 536         final Optional<ComponentInstance> result = componentInterfaceOperationBusinessLogic
 537             .createComponentInstanceInterfaceOperation(componentId, componentInstanceId, interfaceDefinition,
 538                 ComponentTypeEnum.SERVICE, new Wrapper<>(), true);
 539         assertThat(result).isEmpty();
 540     }
 541
 542     private void initComponentData() {
 543         try {
 544             component = new Service();
 545             component.setName("MyTestService");
 546             component.setUniqueId("dac65869-dfb4-40d2-aa20-084324659ec1");
 547
 548             componentInstance = new ComponentInstance();
 549             componentInstance.setUniqueId("dac65869-dfb4-40d2-aa20-084324659ec1.resource0");
 550             componentInstance.setOriginType(OriginTypeEnum.VFC);
 551             componentInstance.setName("My VFC Instance");
 552
 553             componentFilter = new ComponentParametersView();
 554             componentFilter.disableAll();
 555             componentFilter.setIgnoreUsers(false);
 556             componentFilter.setIgnoreComponentInstances(false);
 557             componentFilter.setIgnoreInterfaces(false);
 558             componentFilter.setIgnoreComponentInstancesInterfaces(false);
 559
 560         } catch (final Exception e) {
 561             fail(e.getMessage());
 562         }
 563     }
 564 }