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
  22 import java.util.Arrays;
  23 import java.util.Collections;
  24 import java.util.HashMap;
  25 import java.util.List;
  26 import java.util.Map;
  27 import org.junit.Assert;
  28 import org.junit.Before;
  29 import org.junit.Test;
  30 import org.mockito.Mockito;
  31 import org.mockito.MockitoAnnotations;
  32 import org.openecomp.sdc.be.components.impl.ResponseFormatManager;
  33 import org.openecomp.sdc.be.components.utils.ResourceBuilder;
  34 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  35 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
  36 import org.openecomp.sdc.be.datatypes.elements.OperationOutputDefinition;
  37 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  38 import org.openecomp.sdc.be.model.ArtifactDefinition;
  39 import org.openecomp.sdc.be.model.Component;
  40 import org.openecomp.sdc.be.model.InputDefinition;
  41 import org.openecomp.sdc.be.model.InterfaceDefinition;
  42 import org.openecomp.sdc.be.model.Operation;
  43 import org.openecomp.sdc.exception.ResponseFormat;
  44 import org.openecomp.sdc.test.utils.InterfaceOperationTestUtils;
  45
  46 public class InterfaceOperationValidationTest {
  47
  48     private static final String resourceId = "resourceId";
  49     private static final String interfaceId = "interfaceId";
  50     private static final String operationId = "operationId";
  51     private static final String interfaceType = "interfaceType";
  52     private static final String operationType = "operationType";
  53     private static final String operationId2 = "operationId2";
  54     private static final String inputId = "inputId";
  55     private static final String outputId = "outputId";
  56     private final InterfaceOperationValidationUtilTest interfaceOperationValidationUtilTest =
  57             new InterfaceOperationValidationUtilTest();
  58     private final ListDataDefinition<OperationInputDefinition> operationInputDefinitionList =
  59             new ListDataDefinition<>();
  60     private final ListDataDefinition<OperationOutputDefinition> operationOutputDefinitionList =
  61             new ListDataDefinition<>();
  62     private Component component;
  63     private ResponseFormatManager responseFormatManagerMock;
  64
  65     @Before
  66     public void setup() {
  67         MockitoAnnotations.initMocks(this);
  68         responseFormatManagerMock = Mockito.mock(ResponseFormatManager.class);
  69         when(responseFormatManagerMock.getResponseFormat(any())).thenReturn(new ResponseFormat());
  70         when(responseFormatManagerMock.getResponseFormat(any(), any())).thenReturn(new ResponseFormat());
  71         when(responseFormatManagerMock.getResponseFormat(any(), any(), any())).thenReturn(new ResponseFormat());
  72
  73         component = new ResourceBuilder().setComponentType(ComponentTypeEnum.RESOURCE).setUniqueId(resourceId)
  74                             .setName(resourceId).build();
  75         component.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinitionMap(interfaceId, operationId));
  76         component.setInputs(createInputsForComponent());
  77     }
  78
  79     private List<InputDefinition> createInputsForComponent() {
  80         InputDefinition inputDefinition1 = new InputDefinition();
  81         inputDefinition1.setName(inputId);
  82         inputDefinition1.setInputId(inputId);
  83         inputDefinition1.setUniqueId(inputId);
  84         inputDefinition1.setValue(inputId);
  85         inputDefinition1.setDefaultValue(inputId);
  86
  87         InputDefinition inputDefinition2 = new InputDefinition();
  88         inputDefinition2.setName(outputId);
  89         inputDefinition2.setInputId(outputId);
  90         inputDefinition2.setUniqueId(outputId);
  91         inputDefinition2.setValue(outputId);
  92         inputDefinition2.setDefaultValue(outputId);
  93
  94         return Arrays.asList(inputDefinition1, inputDefinition2);
  95     }
  96
  97     @Test
  98     public void shouldPassOperationValidationForHappyScenario() {
  99         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 100         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
 101         InterfaceDefinition interfaceDefinition =
 102                 createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
 103                         operationInputDefinitionList, operationOutputDefinitionList, "upgrade");
 104         Assert.assertTrue(interfaceOperationValidationUtilTest
 105                                   .validateInterfaceOperations(interfaceDefinition, component,
 106                                           component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
 107                                   .isLeft());
 108     }
 109
 110     private InterfaceDefinition createInterfaceOperationData(String uniqueId, String description,
 111             ArtifactDefinition artifactDefinition, ListDataDefinition<OperationInputDefinition> inputs,
 112             ListDataDefinition<OperationOutputDefinition> outputs, String name) {
 113         Operation operation = new Operation();
 114         operation.setUniqueId(uniqueId);
 115         operation.setDescription(description);
 116         operation.setImplementation(artifactDefinition);
 117         operation.setInputs(inputs);
 118         operation.setOutputs(outputs);
 119         operation.setName(name);
 120         Map<String, Operation> operationMap = new HashMap<>();
 121         operationMap.put(operation.getUniqueId(), operation);
 122         InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 123         interfaceDefinition.setOperationsMap(operationMap);
 124         return interfaceDefinition;
 125     }
 126
 127     @Test
 128     public void shouldFailWhenOperationNameIsEmpty() {
 129         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 130         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
 131         InterfaceDefinition interfaceDefinition =
 132                 createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
 133                         operationInputDefinitionList, operationOutputDefinitionList, "");
 134         Assert.assertTrue(interfaceOperationValidationUtilTest
 135                                   .validateInterfaceOperations(interfaceDefinition, component,
 136                                           component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
 137                                   .isRight());
 138     }
 139
 140     @Test
 141     public void shouldFailWhenOperationNamesAreNotUniqueForCreate() {
 142         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 143         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
 144         InterfaceDefinition interfaceDefinition =
 145                 createInterfaceOperationData(operationId, operationId2, new ArtifactDefinition(),
 146                         operationInputDefinitionList, operationOutputDefinitionList, operationId);
 147         Assert.assertTrue(interfaceOperationValidationUtilTest
 148                                   .validateInterfaceOperations(interfaceDefinition, component,
 149                                           component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
 150                                   .isRight());
 151     }
 152
 153     @Test
 154     public void shouldNotFailWhenOperationNamesAreNotUniqueForUpdate() {
 155         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 156         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
 157         InterfaceDefinition interfaceDefinition =
 158                 createInterfaceOperationData(operationId, operationId2, new ArtifactDefinition(),
 159                         operationInputDefinitionList, operationOutputDefinitionList, operationId);
 160         Assert.assertTrue(interfaceOperationValidationUtilTest
 161                                   .validateInterfaceOperations(interfaceDefinition, component,
 162                                           component.getInterfaces().get(interfaceId), Collections.emptyMap(), true)
 163                                   .isLeft());
 164     }
 165
 166     @Test
 167     public void shouldFailWhenOperationNameLengthIsInvalid() {
 168         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 169         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
 170         InterfaceDefinition interfaceDefinition =
 171                 createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
 172                         operationInputDefinitionList, operationOutputDefinitionList,
 173                         "interface operation2 -  The Spring Initializer provides a project generator to make you "
 174                                 + "productive with the certain technology stack from the beginning. "
 175                                 + "You can create a skeleton project"
 176                                 + "with web, data access (relational and NoSQL data stores), "
 177                                 + "cloud, or messaging support");
 178         Assert.assertTrue(interfaceOperationValidationUtilTest
 179                                   .validateInterfaceOperations(interfaceDefinition, component,
 180                                           component.getInterfaces()
 181                                                   .get(interfaceId), Collections.emptyMap(), false)
 182                                   .isRight());
 183     }
 184
 185     @Test
 186     public void shouldFailWhenOperationInputParamNamesAreNotUnique() {
 187         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 188         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 189         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(outputId));
 190         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
 191         InterfaceDefinition interfaceDefinition =
 192                 createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
 193                         operationInputDefinitionList, operationOutputDefinitionList, "create");
 194         Assert.assertTrue(interfaceOperationValidationUtilTest
 195                                   .validateInterfaceOperations(interfaceDefinition, component,
 196                                           component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
 197                                   .isRight());
 198     }
 199
 200     @Test
 201     public void shouldPassWhenOperationInputParamNamesAreUnique() {
 202         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 203         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(outputId));
 204         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
 205         InterfaceDefinition interfaceDefinition =
 206                 createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
 207                         operationInputDefinitionList, operationOutputDefinitionList, "update");
 208         Assert.assertTrue(interfaceOperationValidationUtilTest
 209                                   .validateInterfaceOperations(interfaceDefinition, component,
 210                                           component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
 211                                   .isLeft());
 212     }
 213
 214     @Test
 215     public void shouldPassWhenOperationInputParamNamesHasSubProperty() {
 216         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 217         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
 218         InterfaceDefinition interfaceDefinition =
 219                 createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
 220                         operationInputDefinitionList, operationOutputDefinitionList, "update");
 221         operationInputDefinitionList.getListToscaDataDefinition().get(0).setInputId(
 222                 operationInputDefinitionList.getListToscaDataDefinition().get(0).getInputId().concat(".subproperty"));
 223         Assert.assertTrue(interfaceOperationValidationUtilTest
 224                                   .validateInterfaceOperations(interfaceDefinition, component,
 225                                           component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
 226                                   .isLeft());
 227     }
 228
 229     @Test
 230     public void shouldFailWhenOperationInputParamNameEmpty() {
 231         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("  "));
 232         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 233         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
 234         InterfaceDefinition interfaceDefinition =
 235                 createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
 236                         operationInputDefinitionList, operationOutputDefinitionList, "update");
 237         Assert.assertTrue(interfaceOperationValidationUtilTest
 238                                   .validateInterfaceOperations(interfaceDefinition, component,
 239                                           component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
 240                                   .isRight());
 241     }
 242
 243     @Test
 244     public void shouldFailWhenOperationOutputParamNameEmpty() {
 245         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 246         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(" "));
 247         InterfaceDefinition interfaceDefinition =
 248                 createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
 249                         operationInputDefinitionList, operationOutputDefinitionList, "update");
 250         Assert.assertTrue(interfaceOperationValidationUtilTest
 251                                   .validateInterfaceOperations(interfaceDefinition, component,
 252                                           component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
 253                                   .isRight());
 254     }
 255
 256     @Test
 257     public void shouldPassWhenInterfaceOperationOutputParamNamesUnique() {
 258         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 259         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(inputId));
 260         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
 261         InterfaceDefinition interfaceDefinition =
 262                 createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
 263                         operationInputDefinitionList, operationOutputDefinitionList, "update");
 264         Assert.assertTrue(interfaceOperationValidationUtilTest
 265                                   .validateInterfaceOperations(interfaceDefinition, component,
 266                                           component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
 267                                   .isLeft());
 268     }
 269
 270     @Test
 271     public void shouldFailWhenOperationOutputParamNamesAreNotUnique() {
 272         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 273         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(inputId));
 274         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
 275         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
 276         InterfaceDefinition interfaceDefinition =
 277                 createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
 278                         operationInputDefinitionList, operationOutputDefinitionList, "update");
 279         Assert.assertTrue(interfaceOperationValidationUtilTest
 280                                   .validateInterfaceOperations(interfaceDefinition, component,
 281                                           component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
 282                                   .isRight());
 283     }
 284
 285     @Test
 286     public void shouldPassWhenOperationInputParamExistInComponentProperty() {
 287         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 288         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
 289         InterfaceDefinition interfaceDefinition =
 290                 createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
 291                         operationInputDefinitionList, operationOutputDefinitionList, "update");
 292         Assert.assertTrue(interfaceOperationValidationUtilTest
 293                                   .validateInterfaceOperations(interfaceDefinition, component,
 294                                           component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
 295                                   .isLeft());
 296     }
 297
 298     @Test
 299     public void shouldFailWhenOperationInputParamDoesntExistInComponentProperty() {
 300         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 301         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(operationId));
 302         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
 303         InterfaceDefinition interfaceDefinition =
 304                 createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(),
 305                         operationInputDefinitionList, operationOutputDefinitionList, "update");
 306         Assert.assertTrue(interfaceOperationValidationUtilTest
 307                                   .validateInterfaceOperations(interfaceDefinition, component,
 308                                           component.getInterfaces().get(interfaceId), Collections.emptyMap(), false)
 309                                   .isRight());
 310     }
 311
 312     @Test
 313     public void shouldFailValidateAllowedOperationCountOnLocalInterfaceType() {
 314         InterfaceDefinition inputInterfaceDefinition =
 315                 InterfaceOperationTestUtils.createMockInterface(interfaceId, operationType);
 316         Assert.assertTrue(interfaceOperationValidationUtilTest
 317                                   .validateInterfaceOperations(inputInterfaceDefinition, component,
 318                                           component.getInterfaces().get(interfaceId),
 319                                           InterfaceOperationTestUtils.createMockInterfaceTypeMap(interfaceType,
 320                                                   operationType),
 321                                           false).isRight());
 322     }
 323
 324     @Test
 325     public void shouldFailValidateAllowedOperationsOnGlobalInterfaceType() {
 326         InterfaceDefinition inputInterfaceDefinition =
 327                 InterfaceOperationTestUtils.createMockInterface(interfaceType, operationId);
 328         Assert.assertTrue(interfaceOperationValidationUtilTest
 329                                   .validateInterfaceOperations(inputInterfaceDefinition, component,
 330                                           component.getInterfaces().get(interfaceId),
 331                                           InterfaceOperationTestUtils.createMockInterfaceTypeMap(interfaceType,
 332                                                   operationType),
 333                                           false).isRight());
 334     }
 335
 336     @Test
 337     public void shouldPassValidateAllowedOperationsOnGlobalInterfaceType() {
 338         InterfaceDefinition inputInterfaceDefinition =
 339                 InterfaceOperationTestUtils.createMockInterface(interfaceType, operationType);
 340         Assert.assertTrue(interfaceOperationValidationUtilTest
 341                                   .validateInterfaceOperations(inputInterfaceDefinition, component,
 342                                           component.getInterfaces().get(interfaceId),
 343                                           InterfaceOperationTestUtils.createMockInterfaceTypeMap(interfaceType,
 344                                                   operationType),
 345                                           false).isLeft());
 346     }
 347
 348     @Test
 349     public void shouldFailValidateOperationNameUniquenessInCollection() {
 350         InterfaceDefinition inputInterfaceDefinition =
 351                 InterfaceOperationTestUtils.createMockInterface(interfaceType, operationType);
 352         inputInterfaceDefinition.getOperations()
 353                 .put(operationId, InterfaceOperationTestUtils.createMockOperation(operationType));
 354         Assert.assertTrue(interfaceOperationValidationUtilTest
 355                                   .validateInterfaceOperations(inputInterfaceDefinition, component,
 356                                           component.getInterfaces().get(interfaceId),
 357                                           InterfaceOperationTestUtils.createMockInterfaceTypeMap(interfaceType,
 358                                                   operationType),
 359                                           false).isRight());
 360     }
 361
 362     private class InterfaceOperationValidationUtilTest extends InterfaceOperationValidation {
 363
 364         protected ResponseFormatManager getResponseFormatManager() {
 365             return responseFormatManagerMock;
 366         }
 367     }
 368 }