2 * Copyright © 2016-2018 European Support Limited
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 package org.openecomp.sdc.be.components.validation;
19 import org.junit.Assert;
20 import org.junit.Before;
21 import org.junit.Test;
22 import org.mockito.Mockito;
23 import org.mockito.MockitoAnnotations;
24 import org.openecomp.sdc.be.components.impl.ResponseFormatManager;
25 import org.openecomp.sdc.be.components.utils.ResourceBuilder;
26 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
27 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
28 import org.openecomp.sdc.be.datatypes.elements.OperationOutputDefinition;
29 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
30 import org.openecomp.sdc.be.model.ArtifactDefinition;
31 import org.openecomp.sdc.be.model.Component;
32 import org.openecomp.sdc.be.model.InputDefinition;
33 import org.openecomp.sdc.be.model.InterfaceDefinition;
34 import org.openecomp.sdc.be.model.Operation;
35 import org.openecomp.sdc.exception.ResponseFormat;
36 import org.openecomp.sdc.test.utils.InterfaceOperationTestUtils;
38 import java.util.Arrays;
39 import java.util.Collections;
40 import java.util.HashMap;
41 import java.util.List;
44 import static org.mockito.ArgumentMatchers.any;
45 import static org.mockito.Mockito.when;
46 import static org.openecomp.sdc.test.utils.InterfaceOperationTestUtils.createMockOperation;
48 public class InterfaceOperationValidationTest {
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";
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<>();
69 private Component component;
70 private ResponseFormatManager responseFormatManagerMock;
75 MockitoAnnotations.openMocks(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());
81 component = new ResourceBuilder()
82 .setComponentType(ComponentTypeEnum.RESOURCE)
83 .setUniqueId(resourceId)
86 component.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinitionMap(interfaceType1,
87 operationId, operationType1));
88 component.setInputs(createInputsForComponent());
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)
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());
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());
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());
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,
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), "
157 + "or messaging support");
158 Assert.assertTrue(interfaceOperationValidationUtilTest
159 .validateInterfaceOperations(interfaceDefinition, component,
160 component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isRight());
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());
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());
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());
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());
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());
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());
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());
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());
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());
295 public void shouldFailValidateAllowedOperationsOnGlobalInterfaceType() {
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 interfaceType1, operationType1), false).isRight());
307 public void shouldPassValidateAllowedOperationsOnGlobalInterfaceType() {
308 InterfaceDefinition inputInterfaceDefinition =
309 InterfaceOperationTestUtils.createMockInterface(interfaceType2,
310 operationId2, operationType2);
311 Assert.assertTrue(interfaceOperationValidationUtilTest
312 .validateInterfaceOperations(inputInterfaceDefinition, component,
313 component.getInterfaces().get(interfaceType1),
314 InterfaceOperationTestUtils.createMockInterfaceTypeMap(
315 interfaceType2, operationType2), false).isLeft());
319 public void shouldFailValidateOperationNameUniquenessInCollection() {
320 InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType1,
321 operationId, operationType1);
322 inputInterfaceDefinition.getOperations().put(operationId,
323 createMockOperation(operationId, operationType1));
324 Assert.assertTrue(interfaceOperationValidationUtilTest
325 .validateInterfaceOperations(inputInterfaceDefinition, component,
326 component.getInterfaces().get(interfaceType1),
327 InterfaceOperationTestUtils.createMockInterfaceTypeMap(
328 interfaceType1, operationType1 ), false).isRight());
332 public void shouldPassValidateWhenInputIsMappedToValidOutput() {
333 InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
334 operationId, operationType1);
335 inputInterfaceDefinition.getOperationsMap().values()
336 .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
337 .forEach(operationInputDefinition -> operationInputDefinition.setInputId(interfaceType1 +
338 "." + operationType1 + "." + outputName1)));
339 Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
340 component, null, Collections.emptyMap(), false).isLeft());
344 public void shouldPassValidateWhenOutputNameIsUnchanged() {
345 InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
346 operationId, operationType1);
347 InterfaceDefinition inputParamOutputMappedInterface = InterfaceOperationTestUtils.createMockInterface(
348 interfaceType2, operationId, operationType1);
349 inputParamOutputMappedInterface.getOperationsMap().values()
350 .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
351 .forEach(operationInputDefinition -> operationInputDefinition.setInputId(interfaceType2 +
352 "." + operationType2 + "." + outputName1)));
353 component.getInterfaces().put(interfaceType2, inputParamOutputMappedInterface);
354 component.getInterfaces().put(interfaceType3, InterfaceOperationTestUtils.createMockInterface(interfaceType3,
355 operationId, operationType2));
356 Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
357 component, component.getInterfaces().get(interfaceType1),
358 Collections.emptyMap(), true).isLeft());
362 public void shouldPassValidateWhenDeletedOutputIsUnMapped() {
363 InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
364 operationId, operationType1);
365 inputInterfaceDefinition.getOperationsMap().values()
366 .forEach(operation -> operation.getOutputs().getListToscaDataDefinition()
367 .forEach(operationOutputDefinition -> operationOutputDefinition.setName(outputName2)));
368 component.getInterfaces().put(interfaceType3, InterfaceOperationTestUtils.createMockInterface(
369 interfaceType3, operationId, operationType2));
370 component.getInterfaces().put(interfaceType2, InterfaceOperationTestUtils.createMockInterface(interfaceType2,
371 operationId, operationType1));
372 Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
373 component, component.getInterfaces().get(interfaceType2),
374 Collections.emptyMap(), true).isLeft());
378 public void shouldPassValidateNoOutputsInExistingInterfaceOperation() {
379 InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType1,
380 operationId, operationType1);
381 inputInterfaceDefinition.getOperationsMap().values()
382 .forEach(operation -> operation.getOutputs().getListToscaDataDefinition()
383 .forEach(operationOutputDefinition -> operationOutputDefinition.setName(outputName2)));
384 operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1));
385 InterfaceDefinition noOutputInterface = createInterfaceOperationData(operationId, "desc",
386 new ArtifactDefinition(), operationInputDefinitionList, null, operationType1);
387 component.getInterfaces().put(interfaceType1, noOutputInterface);
388 component.getInterfaces().put(interfaceType3, InterfaceOperationTestUtils.createMockInterface(
389 interfaceType3, operationId, operationType2));
390 Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
391 component, component.getInterfaces().get(interfaceType1),
392 Collections.emptyMap(), true).isLeft());
396 public void shouldFailValidateMappedOutputDoesNotExistInComponent() {
397 //Input parameter is mapped to invalid output (which does not exist in any of the other operations)
398 InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
399 operationId, operationType1);
400 inputInterfaceDefinition.getOperationsMap().values()
401 .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
402 .forEach(operationInputDefinition -> operationInputDefinition.setInputId(outputName2)));
404 Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
405 component, null, Collections.emptyMap(), false).isRight());
409 public void shouldFailValidateComponentFirstInterfaceInvalidInputMapping() {
410 //Input parameter is mapped to invalid output (which does not exist in any of the other operations)
411 InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
412 operationId, operationType1);
413 inputInterfaceDefinition.getOperationsMap().values()
414 .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
415 .forEach(operationInputDefinition -> operationInputDefinition.setInputId(outputName2)));
416 component.setInterfaces(null);
417 Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
418 component, null, Collections.emptyMap(), false).isRight());
423 public void shouldFailValidateMappedOutputDeletion() {
424 //Input interface from user with new output name (Output2)
425 InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
426 operationId, operationType1);
427 inputInterfaceDefinition.getOperationsMap().values()
428 .forEach(operation -> operation.getOutputs().getListToscaDataDefinition()
429 .forEach(operationOutputDefinition -> operationOutputDefinition.setName(outputName2)));
431 InterfaceDefinition inputParamOutputMappedInterface = InterfaceOperationTestUtils.createMockInterface(
432 interfaceType3, operationId, operationType2);
433 inputParamOutputMappedInterface.getOperationsMap().values()
434 .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
435 .forEach(operationInputDefinition -> operationInputDefinition.setInputId(interfaceType2 +
436 "." + operationType1 + "." + outputName1)));
437 component.getInterfaces().put(interfaceType3, inputParamOutputMappedInterface);
438 component.getInterfaces().put(interfaceType2, InterfaceOperationTestUtils.createMockInterface(interfaceType2,
439 operationId, operationType1));
440 Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
441 component, component.getInterfaces().get(interfaceType2),
442 Collections.emptyMap(), true).isRight());
446 public void shouldFailValidateAllMappedOutputsDeleted() {
447 //Input interface from user with all outputs deleted
448 InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
449 operationId, operationType1);
450 Map<String, Operation> operationsMap = inputInterfaceDefinition.getOperationsMap();
451 for (Map.Entry<String, Operation> operationEntry : operationsMap.entrySet()) {
452 operationEntry.getValue().setOutputs(null);
454 inputInterfaceDefinition.setOperationsMap(operationsMap);
456 InterfaceDefinition inputParamOutputMappedInterface = InterfaceOperationTestUtils.createMockInterface(
457 interfaceType3, operationId, operationType2);
458 inputParamOutputMappedInterface.getOperationsMap().values()
459 .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
460 .forEach(operationInputDefinition -> operationInputDefinition.setInputId(interfaceType2 +
461 "." + operationType1 + "." + outputName1)));
462 component.getInterfaces().put(interfaceType3, inputParamOutputMappedInterface);
463 component.getInterfaces().put(interfaceType2, InterfaceOperationTestUtils.createMockInterface(interfaceType2,
464 operationId, operationType1));
465 Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition,
466 component, component.getInterfaces().get(interfaceType2),
467 Collections.emptyMap(), true).isRight());
472 public void shouldFailValidateDeleteOperationOperationWithMappedOutput() {
473 InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2,
474 operationId, operationType1);
475 InterfaceDefinition inputParamOutputMappedInterface = InterfaceOperationTestUtils.createMockInterface(
476 interfaceType3, operationId, operationType2);
477 inputParamOutputMappedInterface.getOperationsMap().values()
478 .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
479 .forEach(operationInputDefinition -> operationInputDefinition.setInputId(interfaceType2 +
480 "." + operationType1 + "." + outputName1)));
481 component.getInterfaces().put(interfaceType3, inputParamOutputMappedInterface);
482 component.getInterfaces().put(interfaceType2, InterfaceOperationTestUtils.createMockInterface(interfaceType2,
483 operationId, operationType1));
484 Assert.assertTrue(interfaceOperationValidationUtilTest.validateDeleteOperationContainsNoMappedOutput(
485 inputInterfaceDefinition.getOperationsMap().get(operationId), component,
486 inputInterfaceDefinition).isRight());
489 private InterfaceDefinition createInterfaceOperationData(String uniqueID, String description,
490 ArtifactDefinition artifactDefinition,
491 ListDataDefinition<OperationInputDefinition> inputs,
492 ListDataDefinition<OperationOutputDefinition> outputs,
494 Operation operation = new Operation();
495 operation.setUniqueId(uniqueID);
496 operation.setDescription(description);
497 operation.setImplementation(artifactDefinition);
498 operation.setInputs(inputs);
499 operation.setOutputs(outputs);
500 operation.setName(name);
501 Map<String, Operation> operationMap = new HashMap<>();
502 operationMap.put(operation.getUniqueId(), operation);
503 InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
504 interfaceDefinition.setType(interfaceType2);
505 interfaceDefinition.setOperationsMap(operationMap);
506 return interfaceDefinition;
509 private List<InputDefinition> createInputsForComponent() {
510 String componentInputName = "ComponentInput1";
511 InputDefinition inputDefinition1 = new InputDefinition();
512 inputDefinition1.setName(componentInputName);
513 inputDefinition1.setInputId(componentInputName + "_inputId");
514 inputDefinition1.setUniqueId(componentInputName + "_uniqueId");
515 inputDefinition1.setValue(componentInputName + "_value");
516 inputDefinition1.setDefaultValue(componentInputName + "_defaultValue");
518 String componentInputName2 = "ComponentInput2";
519 InputDefinition inputDefinition2 = new InputDefinition();
520 inputDefinition2.setName(componentInputName2);
521 inputDefinition2.setInputId(componentInputName2 + "_inputId");
522 inputDefinition2.setUniqueId(componentInputName2 + "_uniqueId");
523 inputDefinition2.setValue(componentInputName2 + "_value");
524 inputDefinition2.setDefaultValue(componentInputName2 + "_defaultValue");
526 return Arrays.asList(inputDefinition1, inputDefinition2);
529 private class InterfaceOperationValidationUtilTest extends InterfaceOperationValidation {
531 protected ResponseFormatManager getResponseFormatManager() {
532 return responseFormatManagerMock;