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 final InterfaceOperationValidationUtilTest interfaceOperationValidationUtilTest = new InterfaceOperationValidationUtilTest();
  49     private final ListDataDefinition<OperationInputDefinition> operationInputDefinitionList = new ListDataDefinition<>();
  50     private final ListDataDefinition<OperationOutputDefinition> operationOutputDefinitionList = new ListDataDefinition<>();
  51     private static final String resourceId = "resourceId";
  52     private static final String interfaceId = "interfaceId";
  53     private static final String operationId = "operationId";
  54     private static final String interfaceType = "interfaceType";
  55     private static final String operationType = "operationType";
  56     private static final String operationId2 = "operationId2";
  57     private static final String inputId = "inputId";
  58     private static final String outputId = "outputId";
  59
  60     private Component component;
  61     private ResponseFormatManager responseFormatManagerMock;
  62
  63     @Before
  64     public void setup() {
  65         MockitoAnnotations.initMocks(this);
  66         responseFormatManagerMock = Mockito.mock(ResponseFormatManager.class);
  67         when(responseFormatManagerMock.getResponseFormat(any())).thenReturn(new ResponseFormat());
  68         when(responseFormatManagerMock.getResponseFormat(any(), any())).thenReturn(new ResponseFormat());
  69         when(responseFormatManagerMock.getResponseFormat(any(), any(), any())).thenReturn(new ResponseFormat());
  70
  71         component = new ResourceBuilder()
  72             .setComponentType(ComponentTypeEnum.RESOURCE)
  73             .setUniqueId(resourceId)
  74             .setName(resourceId)
  75             .build();
  76         component.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinitionMap(interfaceId, operationId));
  77         component.setInputs(createInputsForComponent());
  78     }
  79
  80     @Test
  81     public void shouldPassOperationValidationForHappyScenario() {
  82         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
  83         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
  84         InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList,"upgrade");
  85         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(), false).isLeft());
  86     }
  87
  88     @Test
  89     public void shouldFailWhenOperationNameIsEmpty() {
  90         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
  91         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
  92         InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2,new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList, "");
  93         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(),false).isRight());
  94     }
  95
  96     @Test
  97     public void shouldFailWhenOperationNamesAreNotUniqueForCreate() {
  98         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
  99         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
 100         InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId, operationId2,new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList, operationId);
 101         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(),false).isRight());
 102     }
 103
 104     @Test
 105     public void shouldNotFailWhenOperationNamesAreNotUniqueForUpdate() {
 106         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 107         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
 108         InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId, operationId2,new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList, operationId);
 109         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(),true).isLeft());
 110     }
 111
 112     @Test
 113     public void shouldFailWhenOperationNameLengthIsInvalid() {
 114         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 115         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
 116         InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2,new ArtifactDefinition(), operationInputDefinitionList,
 117                 operationOutputDefinitionList,"interface operation2 -  The Spring Initializer provides a project generator to make you " +
 118                         "productive with the certain technology stack from the beginning. You can create a skeleton project" +
 119                         "with web, data access (relational and NoSQL data stores), cloud, or messaging support");
 120         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(),false).isRight());
 121     }
 122
 123     @Test
 124     public void shouldFailWhenOperationInputParamNamesAreNotUnique() {
 125         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 126         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 127         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(outputId));
 128         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
 129         InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2,new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList,"create");
 130         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(),false).isRight());
 131     }
 132
 133     @Test
 134     public void shouldPassWhenOperationInputParamNamesAreUnique() {
 135         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 136         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(outputId));
 137         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
 138         InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList,"update");
 139         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(),false).isLeft());
 140     }
 141
 142     @Test
 143     public void shouldPassWhenOperationInputParamNamesHasSubProperty() {
 144         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 145         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
 146         InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2,new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList,"update");
 147         operationInputDefinitionList.getListToscaDataDefinition().get(0).setInputId(operationInputDefinitionList.getListToscaDataDefinition().get(0).getInputId().concat(".subproperty"));
 148         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(),false).isLeft());
 149     }
 150
 151     @Test
 152     public void shouldFailWhenOperationInputParamNameEmpty() {
 153         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("  "));
 154         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 155         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
 156         InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2,new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList,"update");
 157         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(),false).isRight());
 158     }
 159
 160     @Test
 161     public void shouldFailWhenOperationOutputParamNameEmpty() {
 162         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 163         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(" "));
 164         InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2,new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList,"update");
 165         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(),false).isRight());
 166     }
 167
 168     @Test
 169     public void shouldPassWhenInterfaceOperationOutputParamNamesUnique() {
 170         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 171         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(inputId));
 172         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
 173         InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2,new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList,"update");
 174         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(),false).isLeft());
 175     }
 176
 177     @Test
 178     public void shouldFailWhenOperationOutputParamNamesAreNotUnique() {
 179         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 180         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(inputId));
 181         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
 182         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
 183         InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2,new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList,"update");
 184         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(),false).isRight());
 185     }
 186
 187     @Test
 188     public void shouldPassWhenOperationInputParamExistInComponentProperty() {
 189         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 190         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
 191         InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList,"update");
 192         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(),false).isLeft());
 193     }
 194
 195     @Test
 196     public void shouldFailWhenOperationInputParamDoesntExistInComponentProperty() {
 197         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId));
 198         operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(operationId));
 199         operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId));
 200         InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2,new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList,"update");
 201         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(),false).isRight());
 202     }
 203
 204     @Test
 205     public void shouldFailValidateAllowedOperationCountOnLocalInterfaceType() {
 206         InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceId, operationType);
 207         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition, component, component.getInterfaces().get(interfaceId), InterfaceOperationTestUtils.createMockInterfaceTypeMap(interfaceType, operationType),false).isRight());
 208     }
 209
 210     @Test
 211     public void shouldFailValidateAllowedOperationsOnGlobalInterfaceType() {
 212         InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType, operationId);
 213         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition, component, component.getInterfaces().get(interfaceId), InterfaceOperationTestUtils.createMockInterfaceTypeMap(interfaceType, operationType),false).isRight());
 214     }
 215
 216     @Test
 217     public void shouldPassValidateAllowedOperationsOnGlobalInterfaceType() {
 218         InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType, operationType);
 219         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition, component, component.getInterfaces().get(interfaceId), InterfaceOperationTestUtils.createMockInterfaceTypeMap(interfaceType, operationType),false).isLeft());
 220     }
 221
 222     @Test
 223     public void shouldFailValidateOperationNameUniquenessInCollection() {
 224         InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType, operationType);
 225         inputInterfaceDefinition.getOperations().put(operationId, InterfaceOperationTestUtils.createMockOperation(operationType));
 226         Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition, component, component.getInterfaces().get(interfaceId), InterfaceOperationTestUtils.createMockInterfaceTypeMap(interfaceType, operationType),false).isRight());
 227     }
 228
 229     private InterfaceDefinition createInterfaceOperationData(String uniqueID, String description, ArtifactDefinition artifactDefinition,
 230                                                              ListDataDefinition<OperationInputDefinition> inputs,
 231                                                              ListDataDefinition<OperationOutputDefinition> outputs, String name) {
 232         Operation operation = new Operation();
 233         operation.setUniqueId(uniqueID);
 234         operation.setDescription(description);
 235         operation.setImplementation(artifactDefinition);
 236         operation.setInputs(inputs);
 237         operation.setOutputs(outputs);
 238         operation.setName(name);
 239         Map<String, Operation> operationMap = new HashMap<>();
 240         operationMap.put(operation.getUniqueId(), operation);
 241         InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 242         interfaceDefinition.setOperationsMap(operationMap);
 243         return interfaceDefinition;
 244     }
 245
 246     private List<InputDefinition> createInputsForComponent(){
 247         InputDefinition inputDefinition1 = new InputDefinition();
 248         inputDefinition1.setName(inputId);
 249         inputDefinition1.setInputId(inputId);
 250         inputDefinition1.setUniqueId(inputId);
 251         inputDefinition1.setValue(inputId);
 252         inputDefinition1.setDefaultValue(inputId);
 253
 254         InputDefinition inputDefinition2 = new InputDefinition();
 255         inputDefinition2.setName(outputId);
 256         inputDefinition2.setInputId(outputId);
 257         inputDefinition2.setUniqueId(outputId);
 258         inputDefinition2.setValue(outputId);
 259         inputDefinition2.setDefaultValue(outputId);
 260
 261         return Arrays.asList(inputDefinition1, inputDefinition2);
 262     }
 263
 264     private class InterfaceOperationValidationUtilTest extends InterfaceOperationValidation {
 265
 266         protected ResponseFormatManager getResponseFormatManager() {
 267             return responseFormatManagerMock;
 268         }
 269     }
 270 }