catalog-be/src/test/java/org/openecomp/sdc/be/components/validation/InterfaceOperationValidationTest.java

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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
  17 package org.openecomp.sdc.be.components.validation;
  18
  19 import org.junit.Assert;
  20 import org.junit.Before;
  21 import org.junit.Test;
  22 import org.mockito.Mockito;
  23 import org.mockito.MockitoAnnotations;
  24 import org.openecomp.sdc.be.components.impl.ResponseFormatManager;
  25 import org.openecomp.sdc.be.components.utils.ResourceBuilder;
  26 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  27 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
  28 import org.openecomp.sdc.be.datatypes.elements.OperationOutputDefinition;
  29 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  30 import org.openecomp.sdc.be.model.ArtifactDefinition;
  31 import org.openecomp.sdc.be.model.Component;
  32 import org.openecomp.sdc.be.model.InputDefinition;
  33 import org.openecomp.sdc.be.model.InterfaceDefinition;
  34 import org.openecomp.sdc.be.model.Operation;
  35 import org.openecomp.sdc.exception.ResponseFormat;
  36 import org.openecomp.sdc.test.utils.InterfaceOperationTestUtils;
  37
  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
  44 import static org.mockito.ArgumentMatchers.any;
  45 import static org.mockito.Mockito.when;
  46 import static org.openecomp.sdc.test.utils.InterfaceOperationTestUtils.createMockOperation;
  47
  48 public class InterfaceOperationValidationTest {
  49
  50     private static final String resourceId = "resourceId";
  51     private static final String operationId = "operationId";
  52     private static final String operationId2 = "operationId2";
  53     private static final String interfaceType1 = "org.test.lifecycle.standard.interfaceType.first";
  54     private static final String interfaceType2 = "org.test.lifecycle.standard.interfaceType.second";
  55     private static final String interfaceType3 = "org.test.lifecycle.standard.interfaceType.third";
  56     private static final String operationType1 = "createOperation";
  57     private static final String operationType2 = "updateOperation";
  58     private static final String inputName1 = "Input1";
  59     private static final String outputName1 = "Output1";
  60     private static final String outputName2 = "Output2";
  61
  62     private final InterfaceOperationValidationUtilTest interfaceOperationValidationUtilTest =
  63             new InterfaceOperationValidationUtilTest();
  64     private final ListDataDefinition<OperationInputDefinition> operationInputDefinitionList =
  65             new ListDataDefinition<>();
  66     private final ListDataDefinition<OperationOutputDefinition> operationOutputDefinitionList =
  67             new ListDataDefinition<>();
  68
  69     private Component component;
  70     private ResponseFormatManager responseFormatManagerMock;
  71
  72     @Before
  73     public void setup() {
  74
  75         MockitoAnnotations.initMocks(this);
  76         responseFormatManagerMock = Mockito.mock(ResponseFormatManager.class);
  77         when(responseFormatManagerMock.getResponseFormat(any())).thenReturn(new ResponseFormat());
  78         when(responseFormatManagerMock.getResponseFormat(any(), any())).thenReturn(new ResponseFormat());
  79         when(responseFormatManagerMock.getResponseFormat(any(), any(), any())).thenReturn(new ResponseFormat());
  80
  81         component = new ResourceBuilder()
  82                 .setComponentType(ComponentTypeEnum.RESOURCE)
  83                 .setUniqueId(resourceId)
  84                 .setName(resourceId)
  85                 .build();
  86         component.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinitionMap(interfaceType1,
  87                 operationId, operationType1));
  88         component.setInputs(createInputsForComponent());
  89     }
  90
  91     @Test
  92     public void shouldPassOperationValidationForHappyScenario() {
  93         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
  94         operationOutputDefinitionList
  95                 .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
  96         InterfaceDefinition interfaceDefinition =
  97                 createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
  98                         operationInputDefinitionList, operationOutputDefinitionList, "upgrade");
  99         Assert.assertTrue(interfaceOperationValidationUtilTest
 100                 .validateInterfaceOperations(interfaceDefinition, component,
 101                         component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false)
 102                                   .isLeft());
 103     }
 104
 105     @Test
 106     public void shouldFailWhenOperationNameIsEmpty() {
 107         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
 108         operationOutputDefinitionList
 109                 .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
 110         InterfaceDefinition interfaceDefinition =
 111                 createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
 112                         operationInputDefinitionList, operationOutputDefinitionList, "");
 113         Assert.assertTrue(interfaceOperationValidationUtilTest
 114                 .validateInterfaceOperations(interfaceDefinition, component,
 115                         component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isRight());
 116     }
 117
 118     @Test
 119     public void shouldFailWhenOperationNamesAreNotUniqueForCreate() {
 120         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
 121         operationOutputDefinitionList
 122                 .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
 123         InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId, operationId2,
 124                 new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList, operationType1);
 125         Assert.assertTrue(interfaceOperationValidationUtilTest
 126                 .validateInterfaceOperations(interfaceDefinition, component,
 127                         component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isRight());
 128     }
 129
 130     @Test
 131     public void shouldNotFailWhenOperationNamesAreNotUniqueForUpdate() {
 132         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
 133         operationOutputDefinitionList
 134                 .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
 135         InterfaceDefinition interfaceDefinition =
 136                 createInterfaceOperationData(operationId, operationId2, new ArtifactDefinition(),
 137                         operationInputDefinitionList, operationOutputDefinitionList, operationId);
 138         Assert.assertTrue(interfaceOperationValidationUtilTest
 139                 .validateInterfaceOperations(interfaceDefinition, component,
 140                         component.getInterfaces().get(interfaceType1), Collections.emptyMap(), true).isLeft());
 141     }
 142
 143     @Test
 144     public void shouldFailWhenOperationNameLengthIsInvalid() {
 145         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
 146         operationOutputDefinitionList
 147                 .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
 148         InterfaceDefinition interfaceDefinition =
 149                 createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
 150                         operationInputDefinitionList,operationOutputDefinitionList,
 151
 152                         "interface operation2 -  The Spring Initializer provides a project generator to make you "
 153                                 + "productive with the certain technology stack from the beginning. "
 154                                 + "You can create a "
 155                                 + "skeleton project with web, data access (relational and NoSQL data stores), "
 156                                 + "cloud, "
 157                                 + "or messaging support");
 158         Assert.assertTrue(interfaceOperationValidationUtilTest
 159                 .validateInterfaceOperations(interfaceDefinition, component,
 160                         component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isRight());
 161     }
 162
 163     @Test
 164     public void shouldFailWhenOperationInputParamNamesAreNotUnique() {
 165         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
 166         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
 167         operationInputDefinitionList
 168                 .add(InterfaceOperationTestUtils.createMockOperationInputDefinition(outputName1, 1));
 169         operationOutputDefinitionList
 170                 .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
 171         InterfaceDefinition interfaceDefinition =
 172                 createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
 173                         operationInputDefinitionList, operationOutputDefinitionList, "create");
 174         Assert.assertTrue(interfaceOperationValidationUtilTest
 175                 .validateInterfaceOperations(interfaceDefinition, component,
 176                         component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isRight());
 177     }
 178
 179     @Test
 180     public void shouldPassWhenOperationInputParamNamesAreUnique() {
 181         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
 182         operationInputDefinitionList
 183                 .add(InterfaceOperationTestUtils.createMockOperationInputDefinition(outputName1, 1));
 184         operationOutputDefinitionList
 185                 .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
 186         InterfaceDefinition interfaceDefinition =
 187                 createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
 188                         operationInputDefinitionList, operationOutputDefinitionList, "update");
 189         Assert.assertTrue(interfaceOperationValidationUtilTest
 190                 .validateInterfaceOperations(interfaceDefinition, component,
 191                         component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isLeft());
 192     }
 193
 194     @Test
 195     public void shouldPassWhenOperationInputParamNamesHasSubProperty() {
 196         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
 197         operationOutputDefinitionList
 198                 .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
 199         InterfaceDefinition interfaceDefinition =
 200                 createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
 201                         operationInputDefinitionList, operationOutputDefinitionList, "update");
 202         operationInputDefinitionList.getListToscaDataDefinition().get(0).setInputId(
 203                 operationInputDefinitionList.getListToscaDataDefinition().get(0).getInputId().concat(".subproperty"));
 204         Assert.assertTrue(interfaceOperationValidationUtilTest
 205                 .validateInterfaceOperations(interfaceDefinition, component,
 206                         component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isLeft());
 207     }
 208
 209     @Test
 210     public void shouldFailWhenOperationInputParamNameEmpty() {
 211         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("  ", 1));
 212         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
 213         operationOutputDefinitionList
 214                 .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
 215         InterfaceDefinition interfaceDefinition =
 216                 createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
 217                         operationInputDefinitionList, operationOutputDefinitionList, "update");
 218         Assert.assertTrue(interfaceOperationValidationUtilTest
 219                 .validateInterfaceOperations(interfaceDefinition, component,
 220                         component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isRight());
 221     }
 222
 223     @Test
 224     public void shouldFailWhenOperationOutputParamNameEmpty() {
 225         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
 226         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(" "));
 227         InterfaceDefinition interfaceDefinition =
 228                 createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
 229                         operationInputDefinitionList, operationOutputDefinitionList, "update");
 230         Assert.assertTrue(interfaceOperationValidationUtilTest
 231                 .validateInterfaceOperations(interfaceDefinition, component,
 232                         component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isRight());
 233     }
 234
 235     @Test
 236     public void shouldPassWhenInterfaceOperationOutputParamNamesUnique() {
 237         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
 238         operationOutputDefinitionList
 239                 .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(inputName1));
 240         operationOutputDefinitionList
 241                 .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
 242         InterfaceDefinition interfaceDefinition =
 243                 createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
 244                         operationInputDefinitionList, operationOutputDefinitionList, "update");
 245         Assert.assertTrue(interfaceOperationValidationUtilTest
 246                 .validateInterfaceOperations(interfaceDefinition, component,
 247                         component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isLeft());
 248     }
 249
 250     @Test
 251     public void shouldFailWhenOperationOutputParamNamesAreNotUnique() {
 252         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
 253         operationOutputDefinitionList
 254                 .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(inputName1));
 255         operationOutputDefinitionList
 256                 .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
 257         operationOutputDefinitionList
 258                 .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
 259         InterfaceDefinition interfaceDefinition =
 260                 createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
 261                         operationInputDefinitionList, operationOutputDefinitionList, "update");
 262         Assert.assertTrue(interfaceOperationValidationUtilTest
 263                 .validateInterfaceOperations(interfaceDefinition, component,
 264                         component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isRight());
 265     }
 266
 267     @Test
 268     public void shouldPassWhenOperationInputParamExistInComponentProperty() {
 269         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
 270         operationOutputDefinitionList
 271                 .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
 272         InterfaceDefinition interfaceDefinition =
 273                 createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
 274                         operationInputDefinitionList, operationOutputDefinitionList, "update");
 275         Assert.assertTrue(interfaceOperationValidationUtilTest
 276                 .validateInterfaceOperations(interfaceDefinition, component,
 277                         component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isLeft());
 278     }
 279
 280     @Test
 281     public void shouldFailWhenOperationInputParamDoesntExistInComponentProperty() {
 282         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
 283         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 2));
 284         operationOutputDefinitionList
 285                 .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1));
 286         InterfaceDefinition interfaceDefinition =
 287                 createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
 288                         operationInputDefinitionList, operationOutputDefinitionList, "update");
 289         Assert.assertTrue(interfaceOperationValidationUtilTest
 290                 .validateInterfaceOperations(interfaceDefinition, component,
 291                         component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isRight());
 292     }
 293
 294     @Test
 295     public void shouldFailValidateAllowedOperationsOnGlobalInterfaceType() {
 296         InterfaceDefinition inputInterfaceDefinition =
 297                 InterfaceOperationTestUtils.createMockInterface(interfaceType1
 298                 , operationId, operationType1);
 299         Assert.assertTrue(interfaceOperationValidationUtilTest
 300                 .validateInterfaceOperations(inputInterfaceDefinition, component,
 301                         component.getInterfaces().get(interfaceType1),
 302                         InterfaceOperationTestUtils.createMockInterfaceTypeMap(
 303                                 interfaceType1, operationType1), false).isRight());
 304     }
 305
 306     @Test
 307     public void shouldPassValidateAllowedOperationsOnGlobalInterfaceType() {
 308         InterfaceDefinition inputInterfaceDefinition =
 309                 InterfaceOperationTestUtils.createMockInterface(interfaceType2,
 310                 operationId2, operationType2);
 311         Assert.assertTrue(interfaceOperationValidationUtilTest
 312                 .validateInterfaceOperations(inputInterfaceDefinition, component,
 313                         component.getInterfaces().get(interfaceType1),
 314                         InterfaceOperationTestUtils.createMockInterfaceTypeMap(
 315                                 interfaceType2, operationType2), false).isLeft());
 316     }
 317
 318     @Test
 319     public void shouldFailValidateOperationNameUniquenessInCollection() {
 320         InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType1,
 321                 operationId, operationType1);
 322         inputInterfaceDefinition.getOperations().put(operationId,
 323                 createMockOperation(operationId, operationType1));
 324         Assert.assertTrue(interfaceOperationValidationUtilTest
 325                 .validateInterfaceOperations(inputInterfaceDefinition, component,
 326                         component.getInterfaces().get(interfaceType1),
 327                         InterfaceOperationTestUtils.createMockInterfaceTypeMap(
 328                                 interfaceType1, operationType1 ), false).isRight());
 329     }
 330
 331     @Test
 332     public void shouldPassValidateWhenInputIsMappedToValidOutput() {
 333         InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
 334                 operationId, operationType1);
 335         inputInterfaceDefinition.getOperationsMap().values()
 336                 .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
 337                         .forEach(operationInputDefinition -> operationInputDefinition.setInputId(interfaceType1 +
 338                                 "." + operationType1 + "." + outputName1)));
 339         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
 340                 component, null, Collections.emptyMap(), false).isLeft());
 341     }
 342
 343     @Test
 344     public void shouldPassValidateWhenOutputNameIsUnchanged() {
 345         InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
 346                 operationId, operationType1);
 347         InterfaceDefinition inputParamOutputMappedInterface = InterfaceOperationTestUtils.createMockInterface(
 348                 interfaceType2, operationId, operationType1);
 349         inputParamOutputMappedInterface.getOperationsMap().values()
 350                 .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
 351                         .forEach(operationInputDefinition -> operationInputDefinition.setInputId(interfaceType2 +
 352                                 "." + operationType2 + "." + outputName1)));
 353         component.getInterfaces().put(interfaceType2, inputParamOutputMappedInterface);
 354         component.getInterfaces().put(interfaceType3, InterfaceOperationTestUtils.createMockInterface(interfaceType3,
 355                 operationId, operationType2));
 356         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
 357                 component, component.getInterfaces().get(interfaceType1),
 358                 Collections.emptyMap(), true).isLeft());
 359     }
 360
 361     @Test
 362     public void shouldPassValidateWhenDeletedOutputIsUnMapped() {
 363         InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
 364                 operationId, operationType1);
 365         inputInterfaceDefinition.getOperationsMap().values()
 366                 .forEach(operation -> operation.getOutputs().getListToscaDataDefinition()
 367                         .forEach(operationOutputDefinition -> operationOutputDefinition.setName(outputName2)));
 368         component.getInterfaces().put(interfaceType3, InterfaceOperationTestUtils.createMockInterface(
 369                 interfaceType3, operationId, operationType2));
 370         component.getInterfaces().put(interfaceType2, InterfaceOperationTestUtils.createMockInterface(interfaceType2,
 371                 operationId, operationType1));
 372         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
 373                 component, component.getInterfaces().get(interfaceType2),
 374                 Collections.emptyMap(), true).isLeft());
 375     }
 376
 377     @Test
 378     public void shouldPassValidateNoOutputsInExistingInterfaceOperation() {
 379         InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType1,
 380                 operationId, operationType1);
 381         inputInterfaceDefinition.getOperationsMap().values()
 382                 .forEach(operation -> operation.getOutputs().getListToscaDataDefinition()
 383                         .forEach(operationOutputDefinition -> operationOutputDefinition.setName(outputName2)));
 384         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
 385         InterfaceDefinition noOutputInterface = createInterfaceOperationData(operationId, "desc",
 386                 new ArtifactDefinition(), operationInputDefinitionList, null, operationType1);
 387         component.getInterfaces().put(interfaceType1, noOutputInterface);
 388         component.getInterfaces().put(interfaceType3, InterfaceOperationTestUtils.createMockInterface(
 389                 interfaceType3, operationId, operationType2));
 390         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
 391                 component, component.getInterfaces().get(interfaceType1),
 392                 Collections.emptyMap(), true).isLeft());
 393     }
 394
 395     @Test
 396     public void shouldFailValidateMappedOutputDoesNotExistInComponent() {
 397         //Input parameter is mapped to invalid output (which does not exist in any of the other operations)
 398         InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
 399                 operationId, operationType1);
 400         inputInterfaceDefinition.getOperationsMap().values()
 401                 .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
 402                         .forEach(operationInputDefinition -> operationInputDefinition.setInputId(outputName2)));
 403
 404         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
 405                 component, null, Collections.emptyMap(), false).isRight());
 406     }
 407
 408     @Test
 409     public void shouldFailValidateComponentFirstInterfaceInvalidInputMapping() {
 410         //Input parameter is mapped to invalid output (which does not exist in any of the other operations)
 411         InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
 412                 operationId, operationType1);
 413         inputInterfaceDefinition.getOperationsMap().values()
 414                 .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
 415                         .forEach(operationInputDefinition -> operationInputDefinition.setInputId(outputName2)));
 416         component.setInterfaces(null);
 417         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
 418                 component, null, Collections.emptyMap(), false).isRight());
 419     }
 420
 421
 422     @Test
 423     public void shouldFailValidateMappedOutputDeletion() {
 424         //Input interface from user with new output name (Output2)
 425         InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
 426                 operationId, operationType1);
 427         inputInterfaceDefinition.getOperationsMap().values()
 428                 .forEach(operation -> operation.getOutputs().getListToscaDataDefinition()
 429                         .forEach(operationOutputDefinition -> operationOutputDefinition.setName(outputName2)));
 430
 431         InterfaceDefinition inputParamOutputMappedInterface = InterfaceOperationTestUtils.createMockInterface(
 432                 interfaceType3, operationId, operationType2);
 433         inputParamOutputMappedInterface.getOperationsMap().values()
 434                 .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
 435                         .forEach(operationInputDefinition -> operationInputDefinition.setInputId(interfaceType2 +
 436                                 "." + operationType1 + "." + outputName1)));
 437         component.getInterfaces().put(interfaceType3, inputParamOutputMappedInterface);
 438         component.getInterfaces().put(interfaceType2, InterfaceOperationTestUtils.createMockInterface(interfaceType2,
 439                 operationId, operationType1));
 440         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
 441                 component, component.getInterfaces().get(interfaceType2),
 442                 Collections.emptyMap(), true).isRight());
 443     }
 444
 445     @Test
 446     public void shouldFailValidateAllMappedOutputsDeleted() {
 447         //Input interface from user with all outputs deleted
 448         InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
 449                 operationId, operationType1);
 450         Map<String, Operation> operationsMap = inputInterfaceDefinition.getOperationsMap();
 451         for (Map.Entry<String, Operation> operationEntry : operationsMap.entrySet()) {
 452             operationEntry.getValue().setOutputs(null);
 453         }
 454         inputInterfaceDefinition.setOperationsMap(operationsMap);
 455
 456         InterfaceDefinition inputParamOutputMappedInterface = InterfaceOperationTestUtils.createMockInterface(
 457                 interfaceType3, operationId, operationType2);
 458         inputParamOutputMappedInterface.getOperationsMap().values()
 459                 .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
 460                         .forEach(operationInputDefinition -> operationInputDefinition.setInputId(interfaceType2 +
 461                                 "." + operationType1 + "." + outputName1)));
 462         component.getInterfaces().put(interfaceType3, inputParamOutputMappedInterface);
 463         component.getInterfaces().put(interfaceType2, InterfaceOperationTestUtils.createMockInterface(interfaceType2,
 464                 operationId, operationType1));
 465         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
 466                 component, component.getInterfaces().get(interfaceType2),
 467                 Collections.emptyMap(), true).isRight());
 468     }
 469
 470
 471     @Test
 472     public void shouldFailValidateDeleteOperationOperationWithMappedOutput() {
 473         InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
 474                 operationId, operationType1);
 475         InterfaceDefinition inputParamOutputMappedInterface = InterfaceOperationTestUtils.createMockInterface(
 476                 interfaceType3, operationId, operationType2);
 477         inputParamOutputMappedInterface.getOperationsMap().values()
 478                 .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
 479                         .forEach(operationInputDefinition -> operationInputDefinition.setInputId(interfaceType2 +
 480                                 "." + operationType1 + "." + outputName1)));
 481         component.getInterfaces().put(interfaceType3, inputParamOutputMappedInterface);
 482         component.getInterfaces().put(interfaceType2, InterfaceOperationTestUtils.createMockInterface(interfaceType2,
 483                 operationId, operationType1));
 484         Assert.assertTrue(interfaceOperationValidationUtilTest.validateDeleteOperationContainsNoMappedOutput(
 485                 inputInterfaceDefinition.getOperationsMap().get(operationId), component,
 486                 inputInterfaceDefinition).isRight());
 487     }
 488
 489     private InterfaceDefinition createInterfaceOperationData(String uniqueID, String description,
 490                                                              ArtifactDefinition artifactDefinition,
 491                                                              ListDataDefinition<OperationInputDefinition> inputs,
 492                                                              ListDataDefinition<OperationOutputDefinition> outputs,
 493                                                              String name) {
 494         Operation operation = new Operation();
 495         operation.setUniqueId(uniqueID);
 496         operation.setDescription(description);
 497         operation.setImplementation(artifactDefinition);
 498         operation.setInputs(inputs);
 499         operation.setOutputs(outputs);
 500         operation.setName(name);
 501         Map<String, Operation> operationMap = new HashMap<>();
 502         operationMap.put(operation.getUniqueId(), operation);
 503         InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 504         interfaceDefinition.setType(interfaceType2);
 505         interfaceDefinition.setOperationsMap(operationMap);
 506         return interfaceDefinition;
 507     }
 508
 509     private List<InputDefinition> createInputsForComponent() {
 510         String componentInputName = "ComponentInput1";
 511         InputDefinition inputDefinition1 = new InputDefinition();
 512         inputDefinition1.setName(componentInputName);
 513         inputDefinition1.setInputId(componentInputName + "_inputId");
 514         inputDefinition1.setUniqueId(componentInputName + "_uniqueId");
 515         inputDefinition1.setValue(componentInputName + "_value");
 516         inputDefinition1.setDefaultValue(componentInputName + "_defaultValue");
 517
 518         String componentInputName2 = "ComponentInput2";
 519         InputDefinition inputDefinition2 = new InputDefinition();
 520         inputDefinition2.setName(componentInputName2);
 521         inputDefinition2.setInputId(componentInputName2 + "_inputId");
 522         inputDefinition2.setUniqueId(componentInputName2 + "_uniqueId");
 523         inputDefinition2.setValue(componentInputName2 + "_value");
 524         inputDefinition2.setDefaultValue(componentInputName2 + "_defaultValue");
 525
 526         return Arrays.asList(inputDefinition1, inputDefinition2);
 527     }
 528
 529     private class InterfaceOperationValidationUtilTest extends InterfaceOperationValidation {
 530
 531         protected ResponseFormatManager getResponseFormatManager() {
 532             return responseFormatManagerMock;
 533         }
 534     }
 535 }