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