gerrit.onap Code Review - sdc.git/blob

   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.Collection;
  23 import java.util.HashMap;
  24 import java.util.Map;
  25 import java.util.Set;
  26
  27 import org.junit.Assert;
  28 import org.junit.Before;
  29 import org.junit.Test;
  30 import org.mockito.InjectMocks;
  31 import org.mockito.Mock;
  32 import org.mockito.Mockito;
  33 import org.mockito.MockitoAnnotations;
  34 import org.openecomp.sdc.be.components.InterfaceOperationTestUtils;
  35 import org.openecomp.sdc.be.components.impl.ResponseFormatManager;
  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.model.ArtifactDefinition;
  40 import org.openecomp.sdc.be.model.Component;
  41 import org.openecomp.sdc.be.model.ComponentParametersView;
  42 import org.openecomp.sdc.be.model.InterfaceDefinition;
  43 import org.openecomp.sdc.be.model.Operation;
  44 import org.openecomp.sdc.be.model.Resource;
  45 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
  46 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  47 import org.openecomp.sdc.exception.ResponseFormat;
  48
  49 import com.google.common.collect.Sets;
  50
  51 import fj.data.Either;
  52
  53 public class InterfaceOperationValidationTest implements InterfaceOperationTestUtils {
  54
  55     private Resource  resource = (Resource) getToscaFullElement().left().value();
  56
  57     ResponseFormatManager mock;
  58     @Mock
  59     ToscaOperationFacade toscaOperationFacade;
  60
  61     @InjectMocks
  62     InterfaceOperationValidationUtilTest interfaceOperationValidationUtilTest = new InterfaceOperationValidationUtilTest();
  63     private static final String RESOURCE_ID = "resource1";
  64     ListDataDefinition<OperationInputDefinition> operationInputDefinitionList = new ListDataDefinition<>();
  65     ListDataDefinition<OperationOutputDefinition> operationOutputDefinitionList = new ListDataDefinition<>();
  66     @Before
  67     public void init() {
  68         MockitoAnnotations.initMocks(this);
  69         mock = Mockito.mock(ResponseFormatManager.class);
  70         when(toscaOperationFacade.getToscaElement(any(), any(ComponentParametersView.class))).thenReturn(Either.left(resource));
  71         when(mock.getResponseFormat(any())).thenReturn(new ResponseFormat());
  72         when(mock.getResponseFormat(any(), any())).thenReturn(new ResponseFormat());
  73         when(mock.getResponseFormat(any(), any(), any())).thenReturn(new ResponseFormat());
  74     }
  75
  76
  77     @Test
  78     public void testValidInterfaceOperation() {
  79         operationInputDefinitionList.add(createMockOperationInputDefinition("label1"));
  80         operationOutputDefinitionList.add(createMockOperationOutputDefinition("label1"));
  81         Collection<Operation> operations = createInterfaceOperationData("op2",
  82                 "interface operation2",new ArtifactDefinition(), operationInputDefinitionList,
  83                         operationOutputDefinitionList,"upgrade");
  84         Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest
  85                 .validateInterfaceOperations(operations, RESOURCE_ID, false);
  86         Assert.assertTrue(booleanResponseFormatEither.isLeft());
  87     }
  88
  89     @Test
  90     public void testInterfaceOperationDescriptionLength() {
  91         operationInputDefinitionList.add(createMockOperationInputDefinition("label1"));
  92         operationOutputDefinitionList.add(createMockOperationOutputDefinition("label1"));
  93         Collection<Operation> operations = createInterfaceOperationData("op2",
  94                 "interface operation2 -  The Spring Initializer provides a project generator to make you " +
  95                         "productive with the certain technology stack from the beginning. You can create a skeleton project" +
  96                         "with web, data access (relational and NoSQL datastores), cloud, or messaging support",
  97                 new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList,"update");
  98         Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest
  99                 .validateInterfaceOperations(operations, RESOURCE_ID, false);
 100         Assert.assertTrue(booleanResponseFormatEither.isRight());
 101     }
 102
 103
 104
 105     @Test
 106     public void testInterfaceOperationForEmptyType() {
 107         operationInputDefinitionList.add(createMockOperationInputDefinition("label1"));
 108         operationOutputDefinitionList.add(createMockOperationOutputDefinition("label1"));
 109         Collection<Operation> operations = createInterfaceOperationData("op2",
 110                 "interface operation2",new ArtifactDefinition(), operationInputDefinitionList,
 111                 operationOutputDefinitionList, "");
 112         Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest
 113                 .validateInterfaceOperations(operations, RESOURCE_ID, false);
 114         Assert.assertTrue(booleanResponseFormatEither.isRight());
 115     }
 116
 117     @Test
 118     public void testInterfaceOperationForEmptyInputParam() {
 119         operationInputDefinitionList.add(createMockOperationInputDefinition("label1"));
 120         operationOutputDefinitionList.add(createMockOperationOutputDefinition("label1"));
 121         Collection<Operation> operations = createInterfaceOperationData("op2",
 122                 "interface operation2",new ArtifactDefinition(), operationInputDefinitionList,
 123                 operationOutputDefinitionList,"input2");
 124         Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest
 125                 .validateInterfaceOperations(operations, RESOURCE_ID, false);
 126         Assert.assertTrue(booleanResponseFormatEither.isRight());
 127     }
 128
 129     @Test
 130     public void testInterfaceOperationForNonUniqueType() {
 131         operationInputDefinitionList.add(createMockOperationInputDefinition("label1"));
 132         operationOutputDefinitionList.add(createMockOperationOutputDefinition("label1"));
 133         Collection<Operation> operations = createInterfaceOperationData("op2",
 134                 "interface operation2",new ArtifactDefinition(), operationInputDefinitionList,
 135                 operationOutputDefinitionList,"CREATE");
 136         Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest
 137                 .validateInterfaceOperations(operations, RESOURCE_ID, false);
 138         Assert.assertTrue(booleanResponseFormatEither.isRight());
 139     }
 140
 141     @Test
 142     public void testInterfaceOperationTypeLength() {
 143         operationInputDefinitionList.add(createMockOperationInputDefinition("label1"));
 144         operationOutputDefinitionList.add(createMockOperationOutputDefinition("label1"));
 145         Collection<Operation> operations = createInterfaceOperationData("op2",
 146                 "interface operation2",new ArtifactDefinition(), operationInputDefinitionList,
 147                 operationOutputDefinitionList,
 148                 "interface operation2 -  The Spring Initializer provides a project generator to make you " +
 149                         "productive with the certain technology stack from the beginning. You can create a skeleton project" +
 150                         "with web, data access (relational and NoSQL datastores), cloud, or messaging support");
 151         Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest
 152                 .validateInterfaceOperations(operations, RESOURCE_ID, false);
 153         Assert.assertTrue(booleanResponseFormatEither.isRight());
 154     }
 155
 156
 157     @Test
 158     public void testInterfaceOperationUniqueInputParamNameInvalid() {
 159         operationInputDefinitionList.add(createMockOperationInputDefinition("label1"));
 160         operationInputDefinitionList.add(createMockOperationInputDefinition("label1"));
 161         operationInputDefinitionList.add(createMockOperationInputDefinition("label2"));
 162         operationInputDefinitionList.add(createMockOperationInputDefinition("label2"));
 163         operationOutputDefinitionList.add(createMockOperationOutputDefinition("label1"));
 164         Collection<Operation> operations = createInterfaceOperationData("op2",
 165                 "interface operation2",new ArtifactDefinition(), operationInputDefinitionList,
 166                 operationOutputDefinitionList,"create");
 167
 168         Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest
 169                 .validateInterfaceOperations(operations, RESOURCE_ID, false);
 170         Assert.assertTrue(booleanResponseFormatEither.isRight());
 171     }
 172
 173     @Test
 174     public void testInterfaceOperationUniqueInputParamNameValid() {
 175         operationInputDefinitionList.add(createMockOperationInputDefinition("label1"));
 176         operationInputDefinitionList.add(createMockOperationInputDefinition("label2"));
 177         operationOutputDefinitionList.add(createMockOperationOutputDefinition("label1"));
 178         Collection<Operation> operations = createInterfaceOperationData("op2",
 179                 "interface operation2",new ArtifactDefinition(), operationInputDefinitionList,
 180                 operationOutputDefinitionList,"update");
 181
 182
 183         Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest
 184                 .validateInterfaceOperations(operations, RESOURCE_ID, false);
 185         Assert.assertTrue(booleanResponseFormatEither.isLeft());
 186     }
 187
 188     @Test
 189     public void testInterfaceOperationeInputParamNameEmpty() {
 190         operationInputDefinitionList.add(createMockOperationInputDefinition("  "));
 191         operationInputDefinitionList.add(createMockOperationInputDefinition("label1"));
 192         operationOutputDefinitionList.add(createMockOperationOutputDefinition("label1"));
 193         Collection<Operation> operations = createInterfaceOperationData("op2",
 194                 "interface operation2",new ArtifactDefinition(), operationInputDefinitionList,
 195                 operationOutputDefinitionList,"update");
 196
 197
 198         Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest
 199                 .validateInterfaceOperations(operations, RESOURCE_ID, false);
 200         Assert.assertTrue(booleanResponseFormatEither.isRight());
 201     }
 202
 203     private Set<Operation> createInterfaceOperationData( String uniqueID, String description, ArtifactDefinition artifactDefinition,
 204                                                          ListDataDefinition<OperationInputDefinition> inputs,
 205                                                          ListDataDefinition<OperationOutputDefinition> outputs, String name) {
 206         return Sets.newHashSet(createInterfaceOperation(uniqueID, description, artifactDefinition, inputs, outputs, name));
 207     }
 208
 209     private  <T extends Component> Either<T, StorageOperationStatus> getToscaFullElement() {
 210
 211         return Either.left((T) setUpResourceMock());
 212     }
 213
 214     private Resource setUpResourceMock(){
 215         Resource resource = new Resource();
 216         resource.setInterfaces(createMockInterfaceDefinition());
 217
 218         return  resource;
 219     }
 220
 221     private  Map<String, InterfaceDefinition> createMockInterfaceDefinition() {
 222         Map<String, Operation> operationMap = createMockOperationMap();
 223         Map<String, InterfaceDefinition> interfaceDefinitionMap = new HashMap<>();
 224         interfaceDefinitionMap.put("int1", createInterface("int1", "Interface 1",
 225                 "lifecycle", "tosca", operationMap));
 226
 227         return interfaceDefinitionMap;
 228     }
 229
 230     private class InterfaceOperationValidationUtilTest extends InterfaceOperationValidation {
 231
 232         protected ResponseFormatManager getResponseFormatManager() {
 233             return mock;
 234         }
 235     }
 236 }