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