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 static org.mockito.ArgumentMatchers.any;
  20 import static org.mockito.Mockito.when;
  21 import static org.openecomp.sdc.test.utils.InterfaceOperationTestUtils.createMockOperation;
  22
  23 import java.util.Arrays;
  24 import java.util.Collections;
  25 import java.util.HashMap;
  26 import java.util.List;
  27 import java.util.Map;
  28
  29 import org.junit.Assert;
  30 import org.junit.Before;
  31 import org.junit.Test;
  32 import org.mockito.Mockito;
  33 import org.mockito.MockitoAnnotations;
  34 import org.openecomp.sdc.be.components.impl.ResponseFormatManager;
  35 import org.openecomp.sdc.be.components.utils.ResourceBuilder;
  36 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  37 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
  38 import org.openecomp.sdc.be.datatypes.elements.OperationOutputDefinition;
  39 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  40 import org.openecomp.sdc.be.model.ArtifactDefinition;
  41 import org.openecomp.sdc.be.model.Component;
  42 import org.openecomp.sdc.be.model.InputDefinition;
  43 import org.openecomp.sdc.be.model.InterfaceDefinition;
  44 import org.openecomp.sdc.be.model.Operation;
  45 import org.openecomp.sdc.exception.ResponseFormat;
  46 import org.openecomp.sdc.test.utils.InterfaceOperationTestUtils;
  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 shouldFailValidateAllowedOperationCountOnLocalInterfaceType() {
 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                                 interfaceType2, operationType1), false).isRight());
 304     }
 305
 306     @Test
 307     public void shouldFailValidateAllowedOperationsOnGlobalInterfaceType() {
 308         InterfaceDefinition inputInterfaceDefinition =
 309                 InterfaceOperationTestUtils.createMockInterface(interfaceType1
 310                 , operationId, operationType1);
 311         Assert.assertTrue(interfaceOperationValidationUtilTest
 312                 .validateInterfaceOperations(inputInterfaceDefinition, component,
 313                         component.getInterfaces().get(interfaceType1),
 314                         InterfaceOperationTestUtils.createMockInterfaceTypeMap(
 315                                 interfaceType1, operationType1), false).isRight());
 316     }
 317
 318     @Test
 319     public void shouldPassValidateAllowedOperationsOnGlobalInterfaceType() {
 320         InterfaceDefinition inputInterfaceDefinition =
 321                 InterfaceOperationTestUtils.createMockInterface(interfaceType2,
 322                 operationId2, operationType2);
 323         Assert.assertTrue(interfaceOperationValidationUtilTest
 324                 .validateInterfaceOperations(inputInterfaceDefinition, component,
 325                         component.getInterfaces().get(interfaceType1),
 326                         InterfaceOperationTestUtils.createMockInterfaceTypeMap(
 327                                 interfaceType2, operationType2), false).isLeft());
 328     }
 329
 330     @Test
 331     public void shouldFailValidateOperationNameUniquenessInCollection() {
 332         InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType1,
 333                 operationId, operationType1);
 334         inputInterfaceDefinition.getOperations().put(operationId,
 335                 createMockOperation(operationId, operationType1));
 336         Assert.assertTrue(interfaceOperationValidationUtilTest
 337                 .validateInterfaceOperations(inputInterfaceDefinition, component,
 338                         component.getInterfaces().get(interfaceType1),
 339                         InterfaceOperationTestUtils.createMockInterfaceTypeMap(
 340                                 interfaceType1, operationType1 ), false).isRight());
 341     }
 342
 343     @Test
 344     public void shouldPassValidateWhenInputIsMappedToValidOutput() {
 345         InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
 346                 operationId, operationType1);
 347         inputInterfaceDefinition.getOperationsMap().values()
 348                 .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
 349                         .forEach(operationInputDefinition -> operationInputDefinition.setInputId(interfaceType1 +
 350                                 "." + operationType1 + "." + outputName1)));
 351         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
 352                 component, null, Collections.emptyMap(), false).isLeft());
 353     }
 354
 355     @Test
 356     public void shouldPassValidateWhenOutputNameIsUnchanged() {
 357         InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
 358                 operationId, operationType1);
 359         InterfaceDefinition inputParamOutputMappedInterface = InterfaceOperationTestUtils.createMockInterface(
 360                 interfaceType2, operationId, operationType1);
 361         inputParamOutputMappedInterface.getOperationsMap().values()
 362                 .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
 363                         .forEach(operationInputDefinition -> operationInputDefinition.setInputId(interfaceType2 +
 364                                 "." + operationType2 + "." + outputName1)));
 365         component.getInterfaces().put(interfaceType2, inputParamOutputMappedInterface);
 366         component.getInterfaces().put(interfaceType3, InterfaceOperationTestUtils.createMockInterface(interfaceType3,
 367                 operationId, operationType2));
 368         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
 369                 component, component.getInterfaces().get(interfaceType1),
 370                 Collections.emptyMap(), true).isLeft());
 371     }
 372
 373     @Test
 374     public void shouldPassValidateWhenDeletedOutputIsUnMapped() {
 375         InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
 376                 operationId, operationType1);
 377         inputInterfaceDefinition.getOperationsMap().values()
 378                 .forEach(operation -> operation.getOutputs().getListToscaDataDefinition()
 379                         .forEach(operationOutputDefinition -> operationOutputDefinition.setName(outputName2)));
 380         component.getInterfaces().put(interfaceType3, InterfaceOperationTestUtils.createMockInterface(
 381                 interfaceType3, operationId, operationType2));
 382         component.getInterfaces().put(interfaceType2, InterfaceOperationTestUtils.createMockInterface(interfaceType2,
 383                 operationId, operationType1));
 384         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
 385                 component, component.getInterfaces().get(interfaceType2),
 386                 Collections.emptyMap(), true).isLeft());
 387     }
 388
 389     @Test
 390     public void shouldPassValidateNoOutputsInExistingInterfaceOperation() {
 391         InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType1,
 392                 operationId, operationType1);
 393         inputInterfaceDefinition.getOperationsMap().values()
 394                 .forEach(operation -> operation.getOutputs().getListToscaDataDefinition()
 395                         .forEach(operationOutputDefinition -> operationOutputDefinition.setName(outputName2)));
 396         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
 397         InterfaceDefinition noOutputInterface = createInterfaceOperationData(operationId, "desc",
 398                 new ArtifactDefinition(), operationInputDefinitionList, null, operationType1);
 399         component.getInterfaces().put(interfaceType1, noOutputInterface);
 400         component.getInterfaces().put(interfaceType3, InterfaceOperationTestUtils.createMockInterface(
 401                 interfaceType3, operationId, operationType2));
 402         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
 403                 component, component.getInterfaces().get(interfaceType1),
 404                 Collections.emptyMap(), true).isLeft());
 405     }
 406
 407     @Test
 408     public void shouldFailValidateMappedOutputDoesNotExistInComponent() {
 409         //Input parameter is mapped to invalid output (which does not exist in any of the other operations)
 410         InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
 411                 operationId, operationType1);
 412         inputInterfaceDefinition.getOperationsMap().values()
 413                 .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
 414                         .forEach(operationInputDefinition -> operationInputDefinition.setInputId(outputName2)));
 415
 416         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
 417                 component, null, Collections.emptyMap(), false).isRight());
 418     }
 419
 420     @Test
 421     public void shouldFailValidateComponentFirstInterfaceInvalidInputMapping() {
 422         //Input parameter is mapped to invalid output (which does not exist in any of the other operations)
 423         InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
 424                 operationId, operationType1);
 425         inputInterfaceDefinition.getOperationsMap().values()
 426                 .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
 427                         .forEach(operationInputDefinition -> operationInputDefinition.setInputId(outputName2)));
 428         component.setInterfaces(null);
 429         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
 430                 component, null, Collections.emptyMap(), false).isRight());
 431     }
 432
 433
 434     @Test
 435     public void shouldFailValidateMappedOutputDeletion() {
 436         //Input interface from user with new output name (Output2)
 437         InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
 438                 operationId, operationType1);
 439         inputInterfaceDefinition.getOperationsMap().values()
 440                 .forEach(operation -> operation.getOutputs().getListToscaDataDefinition()
 441                         .forEach(operationOutputDefinition -> operationOutputDefinition.setName(outputName2)));
 442
 443         InterfaceDefinition inputParamOutputMappedInterface = InterfaceOperationTestUtils.createMockInterface(
 444                 interfaceType3, operationId, operationType2);
 445         inputParamOutputMappedInterface.getOperationsMap().values()
 446                 .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
 447                         .forEach(operationInputDefinition -> operationInputDefinition.setInputId(interfaceType2 +
 448                                 "." + operationType1 + "." + outputName1)));
 449         component.getInterfaces().put(interfaceType3, inputParamOutputMappedInterface);
 450         component.getInterfaces().put(interfaceType2, InterfaceOperationTestUtils.createMockInterface(interfaceType2,
 451                 operationId, operationType1));
 452         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
 453                 component, component.getInterfaces().get(interfaceType2),
 454                 Collections.emptyMap(), true).isRight());
 455     }
 456
 457     @Test
 458     public void shouldFailValidateAllMappedOutputsDeleted() {
 459         //Input interface from user with all outputs deleted
 460         InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
 461                 operationId, operationType1);
 462         Map<String, Operation> operationsMap = inputInterfaceDefinition.getOperationsMap();
 463         for (Map.Entry<String, Operation> operationEntry : operationsMap.entrySet()) {
 464             operationEntry.getValue().setOutputs(null);
 465         }
 466         inputInterfaceDefinition.setOperationsMap(operationsMap);
 467
 468         InterfaceDefinition inputParamOutputMappedInterface = InterfaceOperationTestUtils.createMockInterface(
 469                 interfaceType3, operationId, operationType2);
 470         inputParamOutputMappedInterface.getOperationsMap().values()
 471                 .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
 472                         .forEach(operationInputDefinition -> operationInputDefinition.setInputId(interfaceType2 +
 473                                 "." + operationType1 + "." + outputName1)));
 474         component.getInterfaces().put(interfaceType3, inputParamOutputMappedInterface);
 475         component.getInterfaces().put(interfaceType2, InterfaceOperationTestUtils.createMockInterface(interfaceType2,
 476                 operationId, operationType1));
 477         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
 478                 component, component.getInterfaces().get(interfaceType2),
 479                 Collections.emptyMap(), true).isRight());
 480     }
 481
 482
 483     @Test
 484     public void shouldFailValidateDeleteOperationOperationWithMappedOutput() {
 485         InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
 486                 operationId, operationType1);
 487         InterfaceDefinition inputParamOutputMappedInterface = InterfaceOperationTestUtils.createMockInterface(
 488                 interfaceType3, operationId, operationType2);
 489         inputParamOutputMappedInterface.getOperationsMap().values()
 490                 .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
 491                         .forEach(operationInputDefinition -> operationInputDefinition.setInputId(interfaceType2 +
 492                                 "." + operationType1 + "." + outputName1)));
 493         component.getInterfaces().put(interfaceType3, inputParamOutputMappedInterface);
 494         component.getInterfaces().put(interfaceType2, InterfaceOperationTestUtils.createMockInterface(interfaceType2,
 495                 operationId, operationType1));
 496         Assert.assertTrue(interfaceOperationValidationUtilTest.validateDeleteOperationContainsNoMappedOutput(
 497                 inputInterfaceDefinition.getOperationsMap().get(operationId), component,
 498                 inputInterfaceDefinition).isRight());
 499     }
 500
 501     private InterfaceDefinition createInterfaceOperationData(String uniqueID, String description,
 502                                                              ArtifactDefinition artifactDefinition,
 503                                                              ListDataDefinition<OperationInputDefinition> inputs,
 504                                                              ListDataDefinition<OperationOutputDefinition> outputs,
 505                                                              String name) {
 506         Operation operation = new Operation();
 507         operation.setUniqueId(uniqueID);
 508         operation.setDescription(description);
 509         operation.setImplementation(artifactDefinition);
 510         operation.setInputs(inputs);
 511         operation.setOutputs(outputs);
 512         operation.setName(name);
 513         Map<String, Operation> operationMap = new HashMap<>();
 514         operationMap.put(operation.getUniqueId(), operation);
 515         InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 516         interfaceDefinition.setType(interfaceType2);
 517         interfaceDefinition.setOperationsMap(operationMap);
 518         return interfaceDefinition;
 519     }
 520
 521     private List<InputDefinition> createInputsForComponent() {
 522         String componentInputName = "ComponentInput1";
 523         InputDefinition inputDefinition1 = new InputDefinition();
 524         inputDefinition1.setName(componentInputName);
 525         inputDefinition1.setInputId(componentInputName + "_inputId");
 526         inputDefinition1.setUniqueId(componentInputName + "_uniqueId");
 527         inputDefinition1.setValue(componentInputName + "_value");
 528         inputDefinition1.setDefaultValue(componentInputName + "_defaultValue");
 529
 530         String componentInputName2 = "ComponentInput2";
 531         InputDefinition inputDefinition2 = new InputDefinition();
 532         inputDefinition2.setName(componentInputName2);
 533         inputDefinition2.setInputId(componentInputName2 + "_inputId");
 534         inputDefinition2.setUniqueId(componentInputName2 + "_uniqueId");
 535         inputDefinition2.setValue(componentInputName2 + "_value");
 536         inputDefinition2.setDefaultValue(componentInputName2 + "_defaultValue");
 537
 538         return Arrays.asList(inputDefinition1, inputDefinition2);
 539     }
 540
 541     private class InterfaceOperationValidationUtilTest extends InterfaceOperationValidation {
 542
 543         protected ResponseFormatManager getResponseFormatManager() {
 544             return responseFormatManagerMock;
 545         }
 546     }
 547 }