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