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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2021, Nordix Foundation. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  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.assertEquals;
  24 import static org.junit.jupiter.api.Assertions.assertNotNull;
  25 import static org.junit.jupiter.api.Assertions.assertTrue;
  26 import static org.junit.jupiter.api.Assertions.fail;
  27 import static org.mockito.ArgumentMatchers.any;
  28 import static org.mockito.ArgumentMatchers.anyMap;
  29 import static org.mockito.ArgumentMatchers.anyString;
  30 import static org.mockito.ArgumentMatchers.eq;
  31 import static org.mockito.Mockito.times;
  32 import static org.mockito.Mockito.verify;
  33 import static org.mockito.Mockito.when;
  34
  35 import fj.data.Either;
  36 import java.util.ArrayList;
  37 import java.util.Arrays;
  38 import java.util.Collections;
  39 import java.util.HashMap;
  40 import java.util.List;
  41 import java.util.Map;
  42 import java.util.stream.Collectors;
  43 import javax.ws.rs.core.Response.Status;
  44 import org.apache.commons.collections.CollectionUtils;
  45 import org.junit.jupiter.api.BeforeEach;
  46 import org.junit.jupiter.api.Test;
  47 import org.mockito.InjectMocks;
  48 import org.mockito.Mock;
  49 import org.mockito.MockitoAnnotations;
  50 import org.openecomp.sdc.be.components.attribute.AttributeDeclarationOrchestrator;
  51 import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
  52 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
  53 import org.openecomp.sdc.be.components.validation.UserValidations;
  54 import org.openecomp.sdc.be.config.ConfigurationManager;
  55 import org.openecomp.sdc.be.dao.api.ActionStatus;
  56 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
  57 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  58 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  59 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  60 import org.openecomp.sdc.be.impl.ComponentsUtils;
  61 import org.openecomp.sdc.be.model.AttributeDefinition;
  62 import org.openecomp.sdc.be.model.ComponentInstOutputsMap;
  63 import org.openecomp.sdc.be.model.ComponentInstance;
  64 import org.openecomp.sdc.be.model.ComponentInstanceAttribOutput;
  65 import org.openecomp.sdc.be.model.ComponentInstanceOutput;
  66 import org.openecomp.sdc.be.model.ComponentParametersView;
  67 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  68 import org.openecomp.sdc.be.model.OutputDefinition;
  69 import org.openecomp.sdc.be.model.Service;
  70 import org.openecomp.sdc.be.model.User;
  71 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
  72 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  73 import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
  74 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  75 import org.openecomp.sdc.be.model.operations.impl.AttributeOperation;
  76 import org.openecomp.sdc.be.user.UserBusinessLogic;
  77 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  78 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  79 import org.openecomp.sdc.exception.ResponseFormat;
  80
  81 class OutputsBusinessLogicTest {
  82
  83     private static final String COMPONENT_INSTANCE_ID = "instanceId";
  84     private static final String COMPONENT_ID = "componentId";
  85     private static final String USER_ID = "userId";
  86     private static final String OUTPUT_ID = "outputId";
  87     private static final String OUTPUT_TYPE = "string";
  88     private static final String LISTOUTPUT_NAME = "listOutput";
  89     private static final String LISTOUTPUT_SCHEMA_TYPE = "org.onap.datatypes.listoutput";
  90     private static final String LISTOUTPUT_PROP1_NAME = "prop1";
  91     private static final String LISTOUTPUT_PROP1_TYPE = "string";
  92     private static final String LISTOUTPUT_PROP2_NAME = "prop2";
  93     private static final String LISTOUTPUT_PROP2_TYPE = "integer";
  94     private static final String OLD_VALUE = "old value";
  95     private static final String NEW_VALUE = "new value";
  96     private final ConfigurationManager configurationManager =
  97         new ConfigurationManager(new FSConfigurationSource(ExternalConfiguration.getChangeListener(), "src/test/resources/config/catalog-be"));
  98
  99     @Mock
 100     private ComponentsUtils componentsUtilsMock;
 101     @Mock
 102     private UserBusinessLogic userAdminMock;
 103     @Mock
 104     private ToscaOperationFacade toscaOperationFacadeMock;
 105     @Mock
 106     private UserValidations userValidations;
 107     @Mock
 108     private IGraphLockOperation graphLockOperation;
 109     @Mock
 110     private AttributeDeclarationOrchestrator attributeDeclarationOrchestrator;
 111     @Mock
 112     private ApplicationDataTypeCache applicationDataTypeCache;
 113     @Mock
 114     private AttributeOperation attributeOperation;
 115     @Mock
 116     private JanusGraphDao janusGraphDao;
 117     @Mock
 118     private ResponseFormatManager responseFormatManager;
 119     @InjectMocks
 120     private OutputsBusinessLogic testInstance;
 121
 122     private Service service;
 123
 124     private Map<String, List<ComponentInstanceOutput>> instanceOutputMap;
 125     private List<ComponentInstanceOutput> outputsList;
 126
 127     @BeforeEach
 128     void setUp() {
 129         MockitoAnnotations.openMocks(this);
 130         service = new Service();
 131         service.setUniqueId(COMPONENT_ID);
 132         service.setLastUpdaterUserId(USER_ID);
 133         service.setIsDeleted(false);
 134         service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 135
 136         testInstance.setUserValidations(userValidations);
 137         testInstance.setToscaOperationFacade(toscaOperationFacadeMock);
 138         testInstance.setGraphLockOperation(graphLockOperation);
 139         testInstance.setComponentsUtils(componentsUtilsMock);
 140         testInstance.setJanusGraphDao(janusGraphDao);
 141         testInstance.setApplicationDataTypeCache(applicationDataTypeCache);
 142         testInstance.setAttributeOperation(attributeOperation);
 143
 144         // add a ComponentInstance
 145         final ComponentInstance componentInstance = new ComponentInstance();
 146         componentInstance.setUniqueId(COMPONENT_INSTANCE_ID);
 147         componentInstance.setName(COMPONENT_INSTANCE_ID);
 148         final AttributeDefinition attributeDefinition = new AttributeDefinition();
 149         attributeDefinition.setName("attribName");
 150         componentInstance.setAttributes(Collections.singletonList(attributeDefinition));
 151         service.setComponentInstances(Collections.singletonList(componentInstance));
 152
 153         instanceOutputMap = new HashMap<>();
 154         final ComponentInstanceOutput componentInstanceOutput = new ComponentInstanceOutput();
 155         componentInstanceOutput.setOutputId(OUTPUT_ID);
 156         componentInstanceOutput.setName(OUTPUT_ID);
 157         outputsList = Collections.singletonList(componentInstanceOutput);
 158         instanceOutputMap.put(COMPONENT_INSTANCE_ID, outputsList);
 159         instanceOutputMap.put("someOutputId", Collections.singletonList(new ComponentInstanceOutput()));
 160         service.setComponentInstancesOutputs(instanceOutputMap);
 161         when(userValidations.validateUserExists(USER_ID)).thenReturn(new User());
 162         when(userAdminMock.getUser(USER_ID, false)).thenReturn(new User());
 163     }
 164
 165     @Test
 166     void getComponentInstanceOutputs_ComponentInstanceNotExist() {
 167         when(toscaOperationFacadeMock.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))).thenReturn(Either.left(service));
 168         final Either<List<ComponentInstanceOutput>, ResponseFormat> componentInstanceOutputs = testInstance
 169             .getComponentInstanceOutputs(USER_ID, COMPONENT_ID, "nonExisting");
 170         assertThat(componentInstanceOutputs.isRight()).isTrue();
 171         verify(componentsUtilsMock).getResponseFormat(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND);
 172     }
 173
 174     @Test
 175     void getComponentInstanceOutputs_emptyOutputsMap() {
 176         service.setComponentInstancesOutputs(Collections.emptyMap());
 177         getComponents_emptyOutputs(service);
 178     }
 179
 180     @Test
 181     void getComponentInstanceOutputs_nullOutputsMap() {
 182         service.setComponentInstancesOutputs(null);
 183         getComponents_emptyOutputs(service);
 184     }
 185
 186     @Test
 187     void getComponentInstanceOutputs_instanceHasNoOutputs() {
 188         service.setComponentInstancesOutputs(Collections.singletonMap("someOutputId", new ArrayList<>()));
 189         getComponents_emptyOutputs(service);
 190     }
 191
 192     @Test
 193     void getComponentInstanceOutputs() {
 194         when(toscaOperationFacadeMock.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))).thenReturn(Either.left(service));
 195         final Either<List<ComponentInstanceOutput>, ResponseFormat> componentInstanceOutputs = testInstance
 196             .getComponentInstanceOutputs(USER_ID, COMPONENT_ID, COMPONENT_INSTANCE_ID);
 197         assertEquals("outputId", componentInstanceOutputs.left().value().get(0).getOutputId());
 198     }
 199
 200     @Test
 201     void testDeclareAttributes() {
 202         service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 203         service.setLastUpdaterUserId(USER_ID);
 204         final ComponentInstOutputsMap componentInstOutputsMap = new ComponentInstOutputsMap();
 205         final Map<String, List<ComponentInstanceAttribOutput>> propertiesForDeclaration = new HashMap<>();
 206         propertiesForDeclaration.put(COMPONENT_ID, getPropertiesListForDeclaration());
 207
 208         final List<OutputDefinition> declaredPropertiesToOutputs = getDeclaredProperties();
 209         initMockitoStubbings(declaredPropertiesToOutputs);
 210
 211         final Either<List<OutputDefinition>, ResponseFormat> declaredPropertiesEither =
 212             testInstance.declareAttributes(USER_ID, COMPONENT_ID, ComponentTypeEnum.SERVICE, componentInstOutputsMap);
 213
 214         assertThat(declaredPropertiesEither.isLeft()).isTrue();
 215
 216         final List<OutputDefinition> declaredProperties = declaredPropertiesEither.left().value();
 217         assertThat(CollectionUtils.isNotEmpty(declaredProperties)).isTrue();
 218         assertEquals(1, declaredProperties.size());
 219         assertEquals(declaredProperties, declaredPropertiesToOutputs);
 220     }
 221
 222     @Test
 223     void testDeclareAttributes_fail() {
 224         service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 225         service.setLastUpdaterUserId(USER_ID);
 226         final ComponentInstOutputsMap componentInstOutputsMap = new ComponentInstOutputsMap();
 227         final Map<String, List<ComponentInstanceAttribOutput>> propertiesForDeclaration = new HashMap<>();
 228         propertiesForDeclaration.put(COMPONENT_ID, getPropertiesListForDeclaration());
 229
 230         final List<OutputDefinition> declaredPropertiesToOutputs = getDeclaredProperties();
 231         initMockitoStubbings(declaredPropertiesToOutputs);
 232         when(attributeDeclarationOrchestrator.declareAttributesToOutputs(any(), any())).thenThrow(ByResponseFormatComponentException.class);
 233         final Either<List<OutputDefinition>, ResponseFormat> declaredPropertiesEither =
 234             testInstance.declareAttributes(USER_ID, COMPONENT_ID, ComponentTypeEnum.SERVICE, componentInstOutputsMap);
 235
 236         assertThat(declaredPropertiesEither.isRight()).isTrue();
 237
 238     }
 239
 240     private void initMockitoStubbings(List<OutputDefinition> declaredPropertiesToOutputs) {
 241         when(toscaOperationFacadeMock.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))).thenReturn(Either.left(service));
 242         when(attributeDeclarationOrchestrator.declareAttributesToOutputs(any(), any())).thenReturn(Either.left(declaredPropertiesToOutputs));
 243         when(toscaOperationFacadeMock.addOutputsToComponent(any(), any())).thenReturn(Either.left(declaredPropertiesToOutputs));
 244         when(janusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
 245         when(graphLockOperation.lockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
 246         when(graphLockOperation.unlockComponent(any(), any())).thenReturn(StorageOperationStatus.OK);
 247     }
 248
 249     private void getComponents_emptyOutputs(Service service) {
 250         when(toscaOperationFacadeMock.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))).thenReturn(Either.left(service));
 251         final Either<List<ComponentInstanceOutput>, ResponseFormat> componentInstanceOutputs = testInstance
 252             .getComponentInstanceOutputs(USER_ID, COMPONENT_ID, COMPONENT_INSTANCE_ID);
 253         assertEquals(Collections.emptyList(), componentInstanceOutputs.left().value());
 254     }
 255
 256     private List<ComponentInstanceAttribOutput> getPropertiesListForDeclaration() {
 257         return outputsList.stream().map(this::getPropertyForDeclaration).collect(Collectors.toList());
 258     }
 259
 260     private ComponentInstanceAttribOutput getPropertyForDeclaration(ComponentInstanceOutput componentInstanceOutput) {
 261         final ComponentInstanceAttribOutput propOutput = new ComponentInstanceAttribOutput();
 262         propOutput.setOutput(componentInstanceOutput);
 263         propOutput.setAttributesName(componentInstanceOutput.getName());
 264
 265         return propOutput;
 266     }
 267
 268     private List<OutputDefinition> getDeclaredProperties() {
 269         return outputsList.stream().map(OutputDefinition::new).collect(Collectors.toList());
 270     }
 271
 272     private OutputDefinition setUpListOutput() {
 273         final OutputDefinition listOutput = new OutputDefinition();
 274         listOutput.setName(LISTOUTPUT_NAME);
 275         listOutput.setType("list");
 276         return listOutput;
 277     }
 278
 279     @Test
 280     void test_deleteOutput_listOutput_fail_getComponent() throws Exception {
 281         when(toscaOperationFacadeMock.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class)))
 282             .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
 283         when(componentsUtilsMock.convertFromStorageResponse(StorageOperationStatus.NOT_FOUND)).thenReturn(ActionStatus.RESOURCE_NOT_FOUND);
 284
 285         try {
 286             testInstance.deleteOutput(COMPONENT_ID, USER_ID, LISTOUTPUT_NAME);
 287         } catch (ComponentException e) {
 288             assertEquals(ActionStatus.RESOURCE_NOT_FOUND, e.getActionStatus());
 289             verify(toscaOperationFacadeMock, times(1)).getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class));
 290             return;
 291         }
 292         fail();
 293     }
 294
 295     @Test
 296     void test_deleteOutput_listOutput_fail_validateOutput() throws Exception {
 297         final OutputDefinition listOutput = setUpListOutput();
 298         final String outputId = COMPONENT_ID + "." + listOutput.getName();
 299         listOutput.setUniqueId(outputId);
 300         service.setOutputs(Collections.singletonList(listOutput));
 301         final String NONEXIST_OUTPUT_NAME = "myOutput";
 302
 303         when(toscaOperationFacadeMock.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))).thenReturn(Either.left(service));
 304
 305         try {
 306             testInstance.deleteOutput(COMPONENT_ID, USER_ID, NONEXIST_OUTPUT_NAME);
 307         } catch (ComponentException e) {
 308             assertEquals(ActionStatus.OUTPUT_IS_NOT_CHILD_OF_COMPONENT, e.getActionStatus());
 309             verify(toscaOperationFacadeMock, times(1)).getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class));
 310             return;
 311         }
 312         fail();
 313     }
 314
 315     @Test
 316     void test_deleteOutput_listOutput_fail_lockComponent() throws Exception {
 317         final OutputDefinition listOutput = setUpListOutput();
 318         final String outputId = COMPONENT_ID + "." + listOutput.getName();
 319         listOutput.setUniqueId(outputId);
 320         service.setOutputs(Collections.singletonList(listOutput));
 321
 322         when(toscaOperationFacadeMock.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))).thenReturn(Either.left(service));
 323         when(graphLockOperation.lockComponent(COMPONENT_ID, NodeTypeEnum.Service)).thenReturn(StorageOperationStatus.NOT_FOUND);
 324         when(componentsUtilsMock.convertFromStorageResponse(StorageOperationStatus.NOT_FOUND, ComponentTypeEnum.SERVICE))
 325             .thenReturn(ActionStatus.SERVICE_NOT_FOUND);
 326
 327         try {
 328             testInstance.deleteOutput(COMPONENT_ID, USER_ID, outputId);
 329         } catch (ComponentException e) {
 330             assertEquals(ActionStatus.SERVICE_NOT_FOUND, e.getActionStatus());
 331             verify(toscaOperationFacadeMock, times(1)).getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class));
 332             verify(graphLockOperation, times(1)).lockComponent(COMPONENT_ID, NodeTypeEnum.Service);
 333             return;
 334         }
 335         fail();
 336     }
 337
 338     @Test
 339     void test_deleteOutput_listOutput_fail_deleteOutput() throws Exception {
 340         final OutputDefinition listOutput = setUpListOutput();
 341         final String outputId = COMPONENT_ID + "." + listOutput.getName();
 342         listOutput.setUniqueId(outputId);
 343         service.setOutputs(Collections.singletonList(listOutput));
 344
 345         when(toscaOperationFacadeMock.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))).thenReturn(Either.left(service));
 346         when(graphLockOperation.lockComponent(COMPONENT_ID, NodeTypeEnum.Service)).thenReturn(StorageOperationStatus.OK);
 347         when(toscaOperationFacadeMock.deleteOutputOfResource(service, listOutput.getName())).thenReturn(StorageOperationStatus.BAD_REQUEST);
 348         when(componentsUtilsMock.convertFromStorageResponse(StorageOperationStatus.BAD_REQUEST)).thenReturn(ActionStatus.INVALID_CONTENT);
 349
 350         try {
 351             testInstance.deleteOutput(COMPONENT_ID, USER_ID, outputId);
 352         } catch (ComponentException e) {
 353             assertEquals(ActionStatus.INVALID_CONTENT, e.getActionStatus());
 354             verify(toscaOperationFacadeMock, times(1)).getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class));
 355             verify(graphLockOperation, times(1)).lockComponent(COMPONENT_ID, NodeTypeEnum.Service);
 356             verify(toscaOperationFacadeMock, times(1)).deleteOutputOfResource(service, listOutput.getName());
 357             return;
 358         }
 359         fail();
 360     }
 361
 362     @Test
 363     void test_deleteOutput_output_fail_unDeclare() throws Exception {
 364         final OutputDefinition listOutput = setUpListOutput();
 365         final String outputId = COMPONENT_ID + "." + listOutput.getName();
 366         listOutput.setUniqueId(outputId);
 367         service.setOutputs(Collections.singletonList(listOutput));
 368
 369         when(toscaOperationFacadeMock.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))).thenReturn(Either.left(service));
 370         when(graphLockOperation.lockComponent(COMPONENT_ID, NodeTypeEnum.Service)).thenReturn(StorageOperationStatus.OK);
 371         when(toscaOperationFacadeMock.deleteOutputOfResource(service, listOutput.getName())).thenReturn(StorageOperationStatus.OK);
 372         when(attributeDeclarationOrchestrator.unDeclareAttributesAsOutputs(service, listOutput)).thenReturn(StorageOperationStatus.BAD_REQUEST);
 373         when(componentsUtilsMock.convertFromStorageResponse(StorageOperationStatus.BAD_REQUEST)).thenReturn(ActionStatus.INVALID_CONTENT);
 374
 375         try {
 376             testInstance.deleteOutput(COMPONENT_ID, USER_ID, outputId);
 377         } catch (ComponentException e) {
 378             assertEquals(ActionStatus.INVALID_CONTENT, e.getActionStatus());
 379             verify(attributeDeclarationOrchestrator, times(1)).unDeclareAttributesAsOutputs(service, listOutput);
 380             return;
 381         }
 382         fail();
 383     }
 384
 385     @Test
 386     void test_deleteOutput_output_success() throws Exception {
 387         final OutputDefinition listOutput = setUpListOutput();
 388         final String outputId = COMPONENT_ID + "." + listOutput.getName();
 389         listOutput.setUniqueId(outputId);
 390         service.setOutputs(Collections.singletonList(listOutput));
 391
 392         when(toscaOperationFacadeMock.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))).thenReturn(Either.left(service));
 393         when(graphLockOperation.lockComponent(COMPONENT_ID, NodeTypeEnum.Service)).thenReturn(StorageOperationStatus.OK);
 394         when(toscaOperationFacadeMock.deleteOutputOfResource(service, listOutput.getName())).thenReturn(StorageOperationStatus.OK);
 395         when(attributeDeclarationOrchestrator.unDeclareAttributesAsOutputs(service, listOutput)).thenReturn(StorageOperationStatus.OK);
 396
 397         testInstance.deleteOutput(COMPONENT_ID, USER_ID, outputId);
 398         verify(attributeDeclarationOrchestrator, times(1)).unDeclareAttributesAsOutputs(service, listOutput);
 399     }
 400
 401     @Test
 402     void testCreateOutputsInGraph_OK() {
 403         final Map<String, OutputDefinition> outputs = new HashMap<>();
 404         final var out_1 = new OutputDefinition();
 405         out_1.setName("out-1");
 406         out_1.setValue("{ get_attribute: [ instanceId, attribName ] }");
 407         final var out_2 = new OutputDefinition();
 408         out_2.setName("out-2");
 409         out_2.setValue("{ get_attribute: [ SELF, oneMoreAttribute ] }");
 410         outputs.put(out_1.getName(), out_1);
 411         outputs.put(out_2.getName(), out_2);
 412
 413         final List<OutputDefinition> serviceOutputs = new ArrayList<>();
 414         final var out_3 = new OutputDefinition();
 415         out_3.setName("out-3");
 416         serviceOutputs.add(out_3);
 417         service.setOutputs(serviceOutputs);
 418
 419         final List<OutputDefinition> list = Arrays.asList(out_1, out_2, out_3);
 420         when(toscaOperationFacadeMock.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))).thenReturn(Either.left(service));
 421         when(graphLockOperation.lockComponent(COMPONENT_ID, NodeTypeEnum.Service)).thenReturn(StorageOperationStatus.OK);
 422         when(attributeDeclarationOrchestrator.declareAttributesToOutputs(eq(service), any(ComponentInstOutputsMap.class)))
 423             .thenReturn(Either.left(list));
 424         when(toscaOperationFacadeMock.addOutputsToComponent(anyMap(), anyString())).thenReturn(Either.left(list));
 425
 426         final var result = testInstance.createOutputsInGraph(outputs, service, USER_ID);
 427         assertTrue(result.isLeft());
 428         assertEquals(3, result.left().value().size());
 429         assertEquals(list, result.left().value());
 430     }
 431
 432     @Test
 433     void testCreateOutputsInGraph_NegativeCreateAndAssociateOutputsStatus() {
 434         final Map<String, OutputDefinition> outputs = new HashMap<>();
 435         final var out_1 = new OutputDefinition();
 436         out_1.setName("out-1");
 437         out_1.setValue("{ get_attribute: [ instanceId, attribName ] }");
 438         final var out_2 = new OutputDefinition();
 439         out_2.setName("out-2");
 440         out_2.setValue("{ get_attribute: [ SELF, oneMoreAttribute ] }");
 441         outputs.put(out_1.getName(), out_1);
 442         outputs.put(out_2.getName(), out_2);
 443
 444         final List<OutputDefinition> serviceOutputs = new ArrayList<>();
 445         final var out_3 = new OutputDefinition();
 446         out_3.setName("out-3");
 447         serviceOutputs.add(out_3);
 448         service.setOutputs(serviceOutputs);
 449
 450         final var list = Arrays.asList(out_1, out_2, out_3);
 451         when(toscaOperationFacadeMock.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))).thenReturn(Either.left(service));
 452         when(graphLockOperation.lockComponent(COMPONENT_ID, NodeTypeEnum.Service)).thenReturn(StorageOperationStatus.OK);
 453         when(attributeDeclarationOrchestrator.declareAttributesToOutputs(eq(service), any(ComponentInstOutputsMap.class)))
 454             .thenReturn(Either.left(list));
 455         when(toscaOperationFacadeMock.addOutputsToComponent(anyMap(), eq(COMPONENT_ID)))
 456             .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 457         when(componentsUtilsMock.convertFromStorageResponse(StorageOperationStatus.GENERAL_ERROR)).thenReturn(ActionStatus.GENERAL_ERROR);
 458         when(componentsUtilsMock.getResponseFormat(StorageOperationStatus.GENERAL_ERROR))
 459             .thenReturn(new ResponseFormat(Status.INTERNAL_SERVER_ERROR.getStatusCode()));
 460
 461         final var result = testInstance.createOutputsInGraph(outputs, service, USER_ID);
 462         assertNotNull(result);
 463         assertTrue(result.isRight());
 464         assertEquals(500, result.right().value().getStatus());
 465     }
 466 }