diff options
Diffstat (limited to 'catalog-be/src/test/java')
5 files changed, 517 insertions, 244 deletions
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogicTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogicTest.java index 8509f3e749..df4ef646ee 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogicTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogicTest.java @@ -24,12 +24,13 @@ import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.when; -import fj.data.Either; import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; + +import fj.data.Either; import org.junit.Assert; import org.junit.Before; import org.junit.Test; @@ -70,6 +71,8 @@ public class InterfaceOperationBusinessLogicTest { private static final String RESOURCE_NAME = "Resource1"; private static final String operationId1 = "operationId1"; private static final String interfaceId1 = "interfaceId1"; + private static final String operationName = "createOperation"; + @InjectMocks private InterfaceOperationBusinessLogic interfaceOperationBusinessLogic; @Mock @@ -97,7 +100,8 @@ public class InterfaceOperationBusinessLogicTest { public void setup() { resource = new ResourceBuilder().setComponentType(ComponentTypeEnum.RESOURCE).setUniqueId(resourceId) .setName(RESOURCE_NAME).build(); - resource.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinitionMap(interfaceId, operationId)); + resource.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinitionMap(interfaceId, operationId, + operationName)); resource.setInputs(createInputsForResource()); user = new User(); @@ -126,11 +130,11 @@ public class InterfaceOperationBusinessLogicTest { when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()) .thenReturn(Either.left(Collections.emptyMap())); when(interfaceOperation.updateInterfaces(any(), any())).thenReturn(Either.left( - Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)))); + Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId, operationName)))); Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither = interfaceOperationBusinessLogic.createInterfaceOperation(resourceId, - Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, - operationId)), + Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, + operationId, operationName)), user, true); Assert.assertTrue(interfaceOperationEither.isLeft()); } @@ -141,13 +145,13 @@ public class InterfaceOperationBusinessLogicTest { when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()) .thenReturn(Either.left(Collections.emptyMap())); when(interfaceOperation.addInterfaces(any(), any())).thenReturn(Either.left( - Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)))); + Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId, operationName)))); when(interfaceOperation.updateInterfaces(any(), any())).thenReturn(Either.left( - Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)))); + Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId, operationName)))); Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither = interfaceOperationBusinessLogic.createInterfaceOperation(resourceId, Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, - operationId)), + operationId, operationName)), user, true); Assert.assertTrue(interfaceOperationEither.isLeft()); } @@ -162,7 +166,7 @@ public class InterfaceOperationBusinessLogicTest { Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither = interfaceOperationBusinessLogic.createInterfaceOperation(resourceId, Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, - operationId)), + operationId, operationName)), user, true); Assert.assertTrue(interfaceOperationEither.isRight()); } @@ -174,7 +178,7 @@ public class InterfaceOperationBusinessLogicTest { when(interfaceOperation.updateInterfaces(any(), any())) .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND)); Assert.assertTrue(interfaceOperationBusinessLogic.createInterfaceOperation(resourceId, - Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)), + Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId, operationName)), user, true).isRight()); } @@ -185,11 +189,11 @@ public class InterfaceOperationBusinessLogicTest { when(artifactCassandraDao.getCountOfArtifactById(any(String.class))).thenReturn(Either.left(new Long(1))); when(artifactCassandraDao.deleteArtifact(any(String.class))).thenReturn(CassandraOperationStatus.OK); when(interfaceOperation.updateInterfaces(any(), any())).thenReturn(Either.left( - Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)))); + Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId, operationName)))); Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperation = interfaceOperationBusinessLogic.updateInterfaceOperation(resourceId, Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, - operationId)), + operationId, operationName)), user, true); Assert.assertTrue(interfaceOperation.isLeft()); } @@ -203,7 +207,7 @@ public class InterfaceOperationBusinessLogicTest { Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperation = interfaceOperationBusinessLogic.updateInterfaceOperation(resourceId, Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, - operationId)), + operationId, operationName)), user, true); Assert.assertTrue(interfaceOperation.isRight()); } @@ -215,11 +219,11 @@ public class InterfaceOperationBusinessLogicTest { when(artifactCassandraDao.getCountOfArtifactById(any(String.class))) .thenReturn(Either.right(CassandraOperationStatus.NOT_FOUND)); when(interfaceOperation.updateInterfaces(any(), any())).thenReturn(Either.left( - Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)))); + Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId, operationName)))); Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperation = interfaceOperationBusinessLogic.updateInterfaceOperation(resourceId, Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, - operationId)), + operationId, operationName)), user, true); Assert.assertTrue(interfaceOperation.isLeft()); } @@ -231,7 +235,7 @@ public class InterfaceOperationBusinessLogicTest { Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperation = interfaceOperationBusinessLogic.updateInterfaceOperation(resourceId, Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, - operationId)), + operationId, operationName)), user, true); Assert.assertTrue(interfaceOperation.isRight()); } @@ -244,7 +248,7 @@ public class InterfaceOperationBusinessLogicTest { Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither = interfaceOperationBusinessLogic.createInterfaceOperation(resourceId, Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, - operationId)), + operationId, operationName)), user, true); Assert.assertTrue(interfaceOperationEither.isRight()); } @@ -256,7 +260,7 @@ public class InterfaceOperationBusinessLogicTest { Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither = interfaceOperationBusinessLogic.createInterfaceOperation(resourceId, Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, - operationId)), + operationId, operationName)), user, true); Assert.assertTrue(interfaceOperationEither.isRight()); } @@ -271,7 +275,7 @@ public class InterfaceOperationBusinessLogicTest { Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither = interfaceOperationBusinessLogic.createInterfaceOperation(resourceId, Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, - operationId)), + operationId, operationName)), user, true); Assert.assertTrue(interfaceOperationEither.isRight()); } @@ -291,7 +295,7 @@ public class InterfaceOperationBusinessLogicTest { @Test public void deleteInterfaceOperationTestSuccess() { resource.getInterfaces().get(interfaceId).getOperations() - .putAll(InterfaceOperationTestUtils.createMockOperationMap(operationId1)); + .putAll(InterfaceOperationTestUtils.createMockOperationMap(operationId1, operationName)); when(artifactCassandraDao.deleteArtifact(any(String.class))).thenReturn(CassandraOperationStatus.OK); when(interfaceOperation.updateInterfaces(any(), any())).thenReturn(Either.left(Collections.emptyList())); Assert.assertTrue(interfaceOperationBusinessLogic.deleteInterfaceOperation(resourceId, interfaceId, @@ -374,7 +378,7 @@ public class InterfaceOperationBusinessLogicTest { Assert.assertTrue(interfaceOperationBusinessLogic.getInterfaceOperation(resourceId, interfaceId, Collections.singletonList(operationId), user, true).isRight()); Assert.assertTrue(interfaceOperationBusinessLogic.createInterfaceOperation(resourceId, - Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)), + Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId, operationName)), user, true).isRight()); } @@ -387,8 +391,8 @@ public class InterfaceOperationBusinessLogicTest { Assert.assertTrue(interfaceOperationBusinessLogic.getInterfaceOperation(resourceId, interfaceId, Collections.singletonList(operationId), user, true).isRight()); Assert.assertTrue(interfaceOperationBusinessLogic.createInterfaceOperation(resourceId, - Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)), - user, true).isRight()); + Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId, + operationName)), user, true).isRight()); } @Test diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/utils/InterfaceOperationUtilsTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/utils/InterfaceOperationUtilsTest.java index 59f95ba8da..8ceac17d46 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/utils/InterfaceOperationUtilsTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/utils/InterfaceOperationUtilsTest.java @@ -15,6 +15,7 @@ public class InterfaceOperationUtilsTest { private static final String TEST_RESOURCE_NAME = "TestResource"; private static final String operationId = "operationId"; + private static final String operationName = "createOperation"; private static final String interfaceId = "interfaceId"; private static Resource resource; @@ -22,7 +23,8 @@ public class InterfaceOperationUtilsTest { public void setup() { resource = new ResourceBuilder().setComponentType(ComponentTypeEnum.RESOURCE).setName(TEST_RESOURCE_NAME).build(); - resource.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinitionMap(interfaceId, operationId)); + resource.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinitionMap(interfaceId, operationId, + operationName)); } @Test @@ -72,20 +74,20 @@ public class InterfaceOperationUtilsTest { @Test public void testGetOperationFromInterfaceDefinitionSuccess() { Assert.assertTrue(InterfaceOperationUtils.getOperationFromInterfaceDefinition( - InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId), operationId).isPresent()); + InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId, operationName), operationId).isPresent()); } @Test public void testGetOperationFromInterfaceDefinitionFailure() { Assert.assertFalse(InterfaceOperationUtils.getOperationFromInterfaceDefinition( - InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId), TEST_RESOURCE_NAME) + InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId, operationName), TEST_RESOURCE_NAME) .isPresent()); } @Test public void testGetOperationFromInterfaceDefinitionNoOperationMap() { InterfaceDefinition interfaceDefinition = - InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId); + InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId, operationName); interfaceDefinition.getOperations().clear(); Optional<Map.Entry<String, Operation>> operationEntry = InterfaceOperationUtils.getOperationFromInterfaceDefinition(interfaceDefinition, TEST_RESOURCE_NAME); diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/validation/InterfaceOperationValidationTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/validation/InterfaceOperationValidationTest.java index fc1b03ed78..e2d83aef29 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/validation/InterfaceOperationValidationTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/validation/InterfaceOperationValidationTest.java @@ -18,12 +18,14 @@ package org.openecomp.sdc.be.components.validation; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.when; +import static org.openecomp.sdc.test.utils.InterfaceOperationTestUtils.createMockOperation; import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; + import org.junit.Assert; import org.junit.Before; import org.junit.Test; @@ -46,317 +48,476 @@ import org.openecomp.sdc.test.utils.InterfaceOperationTestUtils; public class InterfaceOperationValidationTest { private static final String resourceId = "resourceId"; - private static final String interfaceId = "interfaceId"; private static final String operationId = "operationId"; - private static final String interfaceType = "interfaceType"; - private static final String operationType = "operationType"; private static final String operationId2 = "operationId2"; - private static final String inputId = "inputId"; - private static final String outputId = "outputId"; + private static final String interfaceType1 = "org.test.lifecycle.standard.interfaceType.first"; + private static final String interfaceType2 = "org.test.lifecycle.standard.interfaceType.second"; + private static final String interfaceType3 = "org.test.lifecycle.standard.interfaceType.third"; + private static final String operationType1 = "createOperation"; + private static final String operationType2 = "updateOperation"; + private static final String inputName1 = "Input1"; + private static final String outputName1 = "Output1"; + private static final String outputName2 = "Output2"; + private final InterfaceOperationValidationUtilTest interfaceOperationValidationUtilTest = new InterfaceOperationValidationUtilTest(); private final ListDataDefinition<OperationInputDefinition> operationInputDefinitionList = new ListDataDefinition<>(); private final ListDataDefinition<OperationOutputDefinition> operationOutputDefinitionList = new ListDataDefinition<>(); + private Component component; private ResponseFormatManager responseFormatManagerMock; @Before public void setup() { + MockitoAnnotations.initMocks(this); responseFormatManagerMock = Mockito.mock(ResponseFormatManager.class); when(responseFormatManagerMock.getResponseFormat(any())).thenReturn(new ResponseFormat()); when(responseFormatManagerMock.getResponseFormat(any(), any())).thenReturn(new ResponseFormat()); when(responseFormatManagerMock.getResponseFormat(any(), any(), any())).thenReturn(new ResponseFormat()); - component = new ResourceBuilder().setComponentType(ComponentTypeEnum.RESOURCE).setUniqueId(resourceId) - .setName(resourceId).build(); - component.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinitionMap(interfaceId, operationId)); + component = new ResourceBuilder() + .setComponentType(ComponentTypeEnum.RESOURCE) + .setUniqueId(resourceId) + .setName(resourceId) + .build(); + component.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinitionMap(interfaceType1, + operationId, operationType1)); component.setInputs(createInputsForComponent()); } - private List<InputDefinition> createInputsForComponent() { - InputDefinition inputDefinition1 = new InputDefinition(); - inputDefinition1.setName(inputId); - inputDefinition1.setInputId(inputId); - inputDefinition1.setUniqueId(inputId); - inputDefinition1.setValue(inputId); - inputDefinition1.setDefaultValue(inputId); - - InputDefinition inputDefinition2 = new InputDefinition(); - inputDefinition2.setName(outputId); - inputDefinition2.setInputId(outputId); - inputDefinition2.setUniqueId(outputId); - inputDefinition2.setValue(outputId); - inputDefinition2.setDefaultValue(outputId); - - return Arrays.asList(inputDefinition1, inputDefinition2); - } - @Test public void shouldPassOperationValidationForHappyScenario() { - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1)); + operationOutputDefinitionList + .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1)); InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList, "upgrade"); Assert.assertTrue(interfaceOperationValidationUtilTest - .validateInterfaceOperations(interfaceDefinition, component, - component.getInterfaces().get(interfaceId), Collections.emptyMap(), false) + .validateInterfaceOperations(interfaceDefinition, component, + component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false) .isLeft()); } - private InterfaceDefinition createInterfaceOperationData(String uniqueId, String description, - ArtifactDefinition artifactDefinition, ListDataDefinition<OperationInputDefinition> inputs, - ListDataDefinition<OperationOutputDefinition> outputs, String name) { - Operation operation = new Operation(); - operation.setUniqueId(uniqueId); - operation.setDescription(description); - operation.setImplementation(artifactDefinition); - operation.setInputs(inputs); - operation.setOutputs(outputs); - operation.setName(name); - Map<String, Operation> operationMap = new HashMap<>(); - operationMap.put(operation.getUniqueId(), operation); - InterfaceDefinition interfaceDefinition = new InterfaceDefinition(); - interfaceDefinition.setOperationsMap(operationMap); - return interfaceDefinition; - } - @Test public void shouldFailWhenOperationNameIsEmpty() { - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1)); + operationOutputDefinitionList + .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1)); InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList, ""); Assert.assertTrue(interfaceOperationValidationUtilTest - .validateInterfaceOperations(interfaceDefinition, component, - component.getInterfaces().get(interfaceId), Collections.emptyMap(), false) - .isRight()); + .validateInterfaceOperations(interfaceDefinition, component, + component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isRight()); } @Test public void shouldFailWhenOperationNamesAreNotUniqueForCreate() { - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); - InterfaceDefinition interfaceDefinition = - createInterfaceOperationData(operationId, operationId2, new ArtifactDefinition(), - operationInputDefinitionList, operationOutputDefinitionList, operationId); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1)); + operationOutputDefinitionList + .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1)); + InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId, operationId2, + new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList, operationType1); Assert.assertTrue(interfaceOperationValidationUtilTest - .validateInterfaceOperations(interfaceDefinition, component, - component.getInterfaces().get(interfaceId), Collections.emptyMap(), false) - .isRight()); + .validateInterfaceOperations(interfaceDefinition, component, + component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isRight()); } @Test public void shouldNotFailWhenOperationNamesAreNotUniqueForUpdate() { - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1)); + operationOutputDefinitionList + .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1)); InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId, operationId2, new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList, operationId); Assert.assertTrue(interfaceOperationValidationUtilTest - .validateInterfaceOperations(interfaceDefinition, component, - component.getInterfaces().get(interfaceId), Collections.emptyMap(), true) - .isLeft()); + .validateInterfaceOperations(interfaceDefinition, component, + component.getInterfaces().get(interfaceType1), Collections.emptyMap(), true).isLeft()); } @Test public void shouldFailWhenOperationNameLengthIsInvalid() { - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1)); + operationOutputDefinitionList + .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1)); InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(), - operationInputDefinitionList, operationOutputDefinitionList, + operationInputDefinitionList,operationOutputDefinitionList, + "interface operation2 - The Spring Initializer provides a project generator to make you " + "productive with the certain technology stack from the beginning. " - + "You can create a skeleton project" - + "with web, data access (relational and NoSQL data stores), " - + "cloud, or messaging support"); + + "You can create a " + + "skeleton project with web, data access (relational and NoSQL data stores), " + + "cloud, " + + "or messaging support"); Assert.assertTrue(interfaceOperationValidationUtilTest - .validateInterfaceOperations(interfaceDefinition, component, - component.getInterfaces() - .get(interfaceId), Collections.emptyMap(), false) - .isRight()); + .validateInterfaceOperations(interfaceDefinition, component, + component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isRight()); } @Test public void shouldFailWhenOperationInputParamNamesAreNotUnique() { - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(outputId)); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1)); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1)); + operationInputDefinitionList + .add(InterfaceOperationTestUtils.createMockOperationInputDefinition(outputName1, 1)); + operationOutputDefinitionList + .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1)); InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList, "create"); Assert.assertTrue(interfaceOperationValidationUtilTest - .validateInterfaceOperations(interfaceDefinition, component, - component.getInterfaces().get(interfaceId), Collections.emptyMap(), false) - .isRight()); + .validateInterfaceOperations(interfaceDefinition, component, + component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isRight()); } @Test public void shouldPassWhenOperationInputParamNamesAreUnique() { - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(outputId)); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1)); + operationInputDefinitionList + .add(InterfaceOperationTestUtils.createMockOperationInputDefinition(outputName1, 1)); + operationOutputDefinitionList + .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1)); InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList, "update"); Assert.assertTrue(interfaceOperationValidationUtilTest - .validateInterfaceOperations(interfaceDefinition, component, - component.getInterfaces().get(interfaceId), Collections.emptyMap(), false) - .isLeft()); + .validateInterfaceOperations(interfaceDefinition, component, + component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isLeft()); } @Test public void shouldPassWhenOperationInputParamNamesHasSubProperty() { - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1)); + operationOutputDefinitionList + .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1)); InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList, "update"); operationInputDefinitionList.getListToscaDataDefinition().get(0).setInputId( operationInputDefinitionList.getListToscaDataDefinition().get(0).getInputId().concat(".subproperty")); Assert.assertTrue(interfaceOperationValidationUtilTest - .validateInterfaceOperations(interfaceDefinition, component, - component.getInterfaces().get(interfaceId), Collections.emptyMap(), false) - .isLeft()); + .validateInterfaceOperations(interfaceDefinition, component, + component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isLeft()); } @Test public void shouldFailWhenOperationInputParamNameEmpty() { - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(" ")); - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(" ", 1)); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1)); + operationOutputDefinitionList + .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1)); InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList, "update"); Assert.assertTrue(interfaceOperationValidationUtilTest - .validateInterfaceOperations(interfaceDefinition, component, - component.getInterfaces().get(interfaceId), Collections.emptyMap(), false) - .isRight()); + .validateInterfaceOperations(interfaceDefinition, component, + component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isRight()); } @Test public void shouldFailWhenOperationOutputParamNameEmpty() { - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1)); operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(" ")); InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList, "update"); Assert.assertTrue(interfaceOperationValidationUtilTest - .validateInterfaceOperations(interfaceDefinition, component, - component.getInterfaces().get(interfaceId), Collections.emptyMap(), false) - .isRight()); + .validateInterfaceOperations(interfaceDefinition, component, + component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isRight()); } @Test public void shouldPassWhenInterfaceOperationOutputParamNamesUnique() { - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(inputId)); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1)); + operationOutputDefinitionList + .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(inputName1)); + operationOutputDefinitionList + .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1)); InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList, "update"); Assert.assertTrue(interfaceOperationValidationUtilTest - .validateInterfaceOperations(interfaceDefinition, component, - component.getInterfaces().get(interfaceId), Collections.emptyMap(), false) - .isLeft()); + .validateInterfaceOperations(interfaceDefinition, component, + component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isLeft()); } @Test public void shouldFailWhenOperationOutputParamNamesAreNotUnique() { - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(inputId)); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1)); + operationOutputDefinitionList + .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(inputName1)); + operationOutputDefinitionList + .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1)); + operationOutputDefinitionList + .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1)); InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList, "update"); Assert.assertTrue(interfaceOperationValidationUtilTest - .validateInterfaceOperations(interfaceDefinition, component, - component.getInterfaces().get(interfaceId), Collections.emptyMap(), false) - .isRight()); + .validateInterfaceOperations(interfaceDefinition, component, + component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isRight()); } @Test public void shouldPassWhenOperationInputParamExistInComponentProperty() { - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1)); + operationOutputDefinitionList + .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1)); InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList, "update"); Assert.assertTrue(interfaceOperationValidationUtilTest - .validateInterfaceOperations(interfaceDefinition, component, - component.getInterfaces().get(interfaceId), Collections.emptyMap(), false) - .isLeft()); + .validateInterfaceOperations(interfaceDefinition, component, + component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isLeft()); } @Test public void shouldFailWhenOperationInputParamDoesntExistInComponentProperty() { - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(operationId)); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1)); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 2)); + operationOutputDefinitionList + .add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputName1)); InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList, "update"); Assert.assertTrue(interfaceOperationValidationUtilTest - .validateInterfaceOperations(interfaceDefinition, component, - component.getInterfaces().get(interfaceId), Collections.emptyMap(), false) - .isRight()); + .validateInterfaceOperations(interfaceDefinition, component, + component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isRight()); } @Test public void shouldFailValidateAllowedOperationCountOnLocalInterfaceType() { InterfaceDefinition inputInterfaceDefinition = - InterfaceOperationTestUtils.createMockInterface(interfaceId, operationType); + InterfaceOperationTestUtils.createMockInterface(interfaceType1 + , operationId, operationType1); Assert.assertTrue(interfaceOperationValidationUtilTest - .validateInterfaceOperations(inputInterfaceDefinition, component, - component.getInterfaces().get(interfaceId), - InterfaceOperationTestUtils.createMockInterfaceTypeMap(interfaceType, - operationType), - false).isRight()); + .validateInterfaceOperations(inputInterfaceDefinition, component, + component.getInterfaces().get(interfaceType1), + InterfaceOperationTestUtils.createMockInterfaceTypeMap( + interfaceType2, operationType1), false).isRight()); } @Test public void shouldFailValidateAllowedOperationsOnGlobalInterfaceType() { InterfaceDefinition inputInterfaceDefinition = - InterfaceOperationTestUtils.createMockInterface(interfaceType, operationId); + InterfaceOperationTestUtils.createMockInterface(interfaceType1 + , operationId, operationType1); Assert.assertTrue(interfaceOperationValidationUtilTest - .validateInterfaceOperations(inputInterfaceDefinition, component, - component.getInterfaces().get(interfaceId), - InterfaceOperationTestUtils.createMockInterfaceTypeMap(interfaceType, - operationType), - false).isRight()); + .validateInterfaceOperations(inputInterfaceDefinition, component, + component.getInterfaces().get(interfaceType1), + InterfaceOperationTestUtils.createMockInterfaceTypeMap( + interfaceType1, operationType1), false).isRight()); } @Test public void shouldPassValidateAllowedOperationsOnGlobalInterfaceType() { InterfaceDefinition inputInterfaceDefinition = - InterfaceOperationTestUtils.createMockInterface(interfaceType, operationType); + InterfaceOperationTestUtils.createMockInterface(interfaceType2, + operationId2, operationType2); Assert.assertTrue(interfaceOperationValidationUtilTest - .validateInterfaceOperations(inputInterfaceDefinition, component, - component.getInterfaces().get(interfaceId), - InterfaceOperationTestUtils.createMockInterfaceTypeMap(interfaceType, - operationType), - false).isLeft()); + .validateInterfaceOperations(inputInterfaceDefinition, component, + component.getInterfaces().get(interfaceType1), + InterfaceOperationTestUtils.createMockInterfaceTypeMap( + interfaceType2, operationType2), false).isLeft()); } @Test public void shouldFailValidateOperationNameUniquenessInCollection() { - InterfaceDefinition inputInterfaceDefinition = - InterfaceOperationTestUtils.createMockInterface(interfaceType, operationType); - inputInterfaceDefinition.getOperations() - .put(operationId, InterfaceOperationTestUtils.createMockOperation(operationType)); + InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType1, + operationId, operationType1); + inputInterfaceDefinition.getOperations().put(operationId, + createMockOperation(operationId, operationType1)); Assert.assertTrue(interfaceOperationValidationUtilTest - .validateInterfaceOperations(inputInterfaceDefinition, component, - component.getInterfaces().get(interfaceId), - InterfaceOperationTestUtils.createMockInterfaceTypeMap(interfaceType, - operationType), - false).isRight()); + .validateInterfaceOperations(inputInterfaceDefinition, component, + component.getInterfaces().get(interfaceType1), + InterfaceOperationTestUtils.createMockInterfaceTypeMap( + interfaceType1, operationType1), false).isRight()); + } + + @Test + public void shouldPassValidateWhenInputIsMappedToValidOutput() { + InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2, + operationId, operationType1); + inputInterfaceDefinition.getOperationsMap().values() + .forEach(operation -> operation.getInputs().getListToscaDataDefinition() + .forEach(operationInputDefinition -> operationInputDefinition.setInputId(interfaceType1 + + "." + operationType1 + "." + outputName1))); + Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition, + component, null, Collections.emptyMap(), false).isLeft()); + } + + @Test + public void shouldPassValidateWhenOutputNameIsUnchanged() { + InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2, + operationId, operationType1); + InterfaceDefinition inputParamOutputMappedInterface = InterfaceOperationTestUtils.createMockInterface( + interfaceType2, operationId, operationType1); + inputParamOutputMappedInterface.getOperationsMap().values() + .forEach(operation -> operation.getInputs().getListToscaDataDefinition() + .forEach(operationInputDefinition -> operationInputDefinition.setInputId(interfaceType2 + + "." + operationType2 + "." + outputName1))); + component.getInterfaces().put(interfaceType2, inputParamOutputMappedInterface); + component.getInterfaces().put(interfaceType3, InterfaceOperationTestUtils.createMockInterface(interfaceType3, + operationId, operationType2)); + Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition, + component, component.getInterfaces().get(interfaceType1), + Collections.emptyMap(), true).isLeft()); + } + + @Test + public void shouldPassValidateWhenDeletedOutputIsUnMapped() { + InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2, + operationId, operationType1); + inputInterfaceDefinition.getOperationsMap().values() + .forEach(operation -> operation.getOutputs().getListToscaDataDefinition() + .forEach(operationOutputDefinition -> operationOutputDefinition.setName(outputName2))); + component.getInterfaces().put(interfaceType3, InterfaceOperationTestUtils.createMockInterface( + interfaceType3, operationId, operationType2)); + component.getInterfaces().put(interfaceType2, InterfaceOperationTestUtils.createMockInterface(interfaceType2, + operationId, operationType1)); + Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition, + component, component.getInterfaces().get(interfaceType2), + Collections.emptyMap(), true).isLeft()); + } + + @Test + public void shouldPassValidateNoOutputsInExistingInterfaceOperation() { + InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType1, + operationId, operationType1); + inputInterfaceDefinition.getOperationsMap().values() + .forEach(operation -> operation.getOutputs().getListToscaDataDefinition() + .forEach(operationOutputDefinition -> operationOutputDefinition.setName(outputName2))); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputName1, 1)); + InterfaceDefinition noOutputInterface = createInterfaceOperationData(operationId, "desc", + new ArtifactDefinition(), operationInputDefinitionList, null, operationType1); + component.getInterfaces().put(interfaceType1, noOutputInterface); + component.getInterfaces().put(interfaceType3, InterfaceOperationTestUtils.createMockInterface( + interfaceType3, operationId, operationType2)); + Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition, + component, component.getInterfaces().get(interfaceType1), + Collections.emptyMap(), true).isLeft()); + } + + @Test + public void shouldFailValidateMappedOutputDoesNotExistInComponent() { + //Input parameter is mapped to invalid output (which does not exist in any of the other operations) + InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2, + operationId, operationType1); + inputInterfaceDefinition.getOperationsMap().values() + .forEach(operation -> operation.getInputs().getListToscaDataDefinition() + .forEach(operationInputDefinition -> operationInputDefinition.setInputId(outputName2))); + + Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition, + component, null, Collections.emptyMap(), false).isRight()); + } + + @Test + public void shouldFailValidateComponentFirstInterfaceInvalidInputMapping() { + //Input parameter is mapped to invalid output (which does not exist in any of the other operations) + InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2, + operationId, operationType1); + inputInterfaceDefinition.getOperationsMap().values() + .forEach(operation -> operation.getInputs().getListToscaDataDefinition() + .forEach(operationInputDefinition -> operationInputDefinition.setInputId(outputName2))); + component.setInterfaces(null); + Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition, + component, null, Collections.emptyMap(), false).isRight()); + } + + + @Test + public void shouldFailValidateMappedOutputDeletion() { + //Input interface from user with new output name (Output2) + InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2, + operationId, operationType1); + inputInterfaceDefinition.getOperationsMap().values() + .forEach(operation -> operation.getOutputs().getListToscaDataDefinition() + .forEach(operationOutputDefinition -> operationOutputDefinition.setName(outputName2))); + + InterfaceDefinition inputParamOutputMappedInterface = InterfaceOperationTestUtils.createMockInterface( + interfaceType3, operationId, operationType2); + inputParamOutputMappedInterface.getOperationsMap().values() + .forEach(operation -> operation.getInputs().getListToscaDataDefinition() + .forEach(operationInputDefinition -> operationInputDefinition.setInputId(interfaceType2 + + "." + operationType1 + "." + outputName1))); + component.getInterfaces().put(interfaceType3, inputParamOutputMappedInterface); + component.getInterfaces().put(interfaceType2, InterfaceOperationTestUtils.createMockInterface(interfaceType2, + operationId, operationType1)); + Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition, + component, component.getInterfaces().get(interfaceType2), + Collections.emptyMap(), true).isRight()); + } + + @Test + public void shouldFailValidateAllMappedOutputsDeleted() { + //Input interface from user with all outputs deleted + InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType2, + operationId, operationType1); + Map<String, Operation> operationsMap = inputInterfaceDefinition.getOperationsMap(); + for (Map.Entry<String, Operation> operationEntry : operationsMap.entrySet()) { + operationEntry.getValue().setOutputs(null); + } + inputInterfaceDefinition.setOperationsMap(operationsMap); + + InterfaceDefinition inputParamOutputMappedInterface = InterfaceOperationTestUtils.createMockInterface( + interfaceType3, operationId, operationType2); + inputParamOutputMappedInterface.getOperationsMap().values() + .forEach(operation -> operation.getInputs().getListToscaDataDefinition() + .forEach(operationInputDefinition -> operationInputDefinition.setInputId(interfaceType2 + + "." + operationType1 + "." + outputName1))); + component.getInterfaces().put(interfaceType3, inputParamOutputMappedInterface); + component.getInterfaces().put(interfaceType2, InterfaceOperationTestUtils.createMockInterface(interfaceType2, + operationId, operationType1)); + Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition, + component, component.getInterfaces().get(interfaceType2), + Collections.emptyMap(), true).isRight()); + } + + + private InterfaceDefinition createInterfaceOperationData(String uniqueID, String description, + ArtifactDefinition artifactDefinition, + ListDataDefinition<OperationInputDefinition> inputs, + ListDataDefinition<OperationOutputDefinition> outputs, + String name) { + Operation operation = new Operation(); + operation.setUniqueId(uniqueID); + operation.setDescription(description); + operation.setImplementation(artifactDefinition); + operation.setInputs(inputs); + operation.setOutputs(outputs); + operation.setName(name); + Map<String, Operation> operationMap = new HashMap<>(); + operationMap.put(operation.getUniqueId(), operation); + InterfaceDefinition interfaceDefinition = new InterfaceDefinition(); + interfaceDefinition.setType(interfaceType2); + interfaceDefinition.setOperationsMap(operationMap); + return interfaceDefinition; + } + + private List<InputDefinition> createInputsForComponent() { + String componentInputName = "ComponentInput1"; + InputDefinition inputDefinition1 = new InputDefinition(); + inputDefinition1.setName(componentInputName); + inputDefinition1.setInputId(componentInputName + "_inputId"); + inputDefinition1.setUniqueId(componentInputName + "_uniqueId"); + inputDefinition1.setValue(componentInputName + "_value"); + inputDefinition1.setDefaultValue(componentInputName + "_defaultValue"); + + String componentInputName2 = "ComponentInput2"; + InputDefinition inputDefinition2 = new InputDefinition(); + inputDefinition2.setName(componentInputName2); + inputDefinition2.setInputId(componentInputName2 + "_inputId"); + inputDefinition2.setUniqueId(componentInputName2 + "_uniqueId"); + inputDefinition2.setValue(componentInputName2 + "_value"); + inputDefinition2.setDefaultValue(componentInputName2 + "_defaultValue"); + + return Arrays.asList(inputDefinition1, inputDefinition2); } private class InterfaceOperationValidationUtilTest extends InterfaceOperationValidation { diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsToscaUtilTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsToscaUtilTest.java index 983ef91a8c..36dd5d9796 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsToscaUtilTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsToscaUtilTest.java @@ -16,12 +16,20 @@ package org.openecomp.sdc.be.tosca.utils; +import static org.openecomp.sdc.be.tosca.utils.InterfacesOperationsToscaUtil.GET_OPERATION_OUTPUT; +import static org.openecomp.sdc.be.tosca.utils.InterfacesOperationsToscaUtil.GET_PROPERTY; +import static org.openecomp.sdc.be.tosca.utils.InterfacesOperationsToscaUtil.SELF; +import static org.openecomp.sdc.be.tosca.utils.InterfacesOperationsToscaUtil.addInterfaceDefinitionElement; +import static org.openecomp.sdc.be.tosca.utils.InterfacesOperationsToscaUtil.addInterfaceTypeElement; + import com.fasterxml.jackson.databind.DeserializationFeature; import com.fasterxml.jackson.databind.ObjectMapper; import java.util.ArrayList; import java.util.HashMap; +import java.util.List; import java.util.Map; +import java.util.Objects; import org.junit.Assert; import org.junit.BeforeClass; @@ -31,15 +39,15 @@ import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition; import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition; import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition; import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition; +import org.openecomp.sdc.be.datatypes.elements.OperationOutputDefinition; import org.openecomp.sdc.be.model.Component; +import org.openecomp.sdc.be.model.InputDefinition; import org.openecomp.sdc.be.model.InterfaceDefinition; import org.openecomp.sdc.be.model.Resource; import org.openecomp.sdc.be.model.Service; import org.openecomp.sdc.be.tosca.ToscaExportHandler; import org.openecomp.sdc.be.tosca.ToscaRepresentation; -import org.openecomp.sdc.be.tosca.model.ToscaLifecycleOperationDefinition; import org.openecomp.sdc.be.tosca.model.ToscaNodeType; -import org.openecomp.sdc.be.tosca.model.ToscaProperty; import org.openecomp.sdc.be.tosca.model.ToscaTemplate; import org.openecomp.sdc.common.util.YamlToObjectConverter; @@ -47,6 +55,7 @@ public class InterfacesOperationsToscaUtilTest { private static final String MAPPED_PROPERTY_NAME = "mapped_property"; private static final String INPUT_NAME_PREFIX = "input_"; + private static final String OUTPUT_NAME_PREFIX = "output_"; private static final String NODE_TYPE_NAME = "test"; private String[] inputTypes = {"string", "integer", "float", "boolean"}; private static ObjectMapper mapper; @@ -65,12 +74,12 @@ public class InterfacesOperationsToscaUtilTest { component.setNormalizedName("normalizedComponentName"); InterfaceDefinition addedInterface = new InterfaceDefinition(); addedInterface.setType("interface.types.test_resource_name"); - addOperationsToInterface(addedInterface, 5, 3, true); + addOperationsToInterface(component, addedInterface, 5, 3, true, false); final String interfaceType = "normalizedComponentName-interface"; component.setInterfaces(new HashMap<>()); component.getInterfaces().put(interfaceType, addedInterface); final Map<String, Object> interfaceTypeElement = - InterfacesOperationsToscaUtil.addInterfaceTypeElement(component, new ArrayList<>()); + addInterfaceTypeElement(component, new ArrayList<>()); ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null); ToscaTemplate template = new ToscaTemplate("test"); @@ -87,12 +96,12 @@ public class InterfacesOperationsToscaUtilTest { component.setNormalizedName("normalizedServiceComponentName"); InterfaceDefinition addedInterface = new InterfaceDefinition(); addedInterface.setType("interface.types.test_service_name"); - addOperationsToInterface(addedInterface, 5, 3, true); + addOperationsToInterface(component, addedInterface, 5, 3, true, false); final String interfaceType = "normalizedServiceComponentName-interface"; component.setInterfaces(new HashMap<>()); component.getInterfaces().put(interfaceType, addedInterface); final Map<String, Object> interfaceTypeElement = - InterfacesOperationsToscaUtil.addInterfaceTypeElement(component, new ArrayList<>()); + addInterfaceTypeElement(component, new ArrayList<>()); ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null); ToscaTemplate template = new ToscaTemplate("testService"); @@ -110,12 +119,12 @@ public class InterfacesOperationsToscaUtilTest { InterfaceDefinition addedInterface = new InterfaceDefinition(); addedInterface.setType("com.some.resource.or.other.resourceName"); - addOperationsToInterface(addedInterface, 3, 2, true); + addOperationsToInterface(component, addedInterface, 3, 2, true, false); final String interfaceType = "normalizedComponentName-interface"; component.setInterfaces(new HashMap<>()); component.getInterfaces().put(interfaceType, addedInterface); ToscaNodeType nodeType = new ToscaNodeType(); - InterfacesOperationsToscaUtil.addInterfaceDefinitionElement(component, nodeType, false); + addInterfaceDefinitionElement(component, nodeType, false); ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null); ToscaTemplate template = new ToscaTemplate(NODE_TYPE_NAME); @@ -128,7 +137,7 @@ public class InterfacesOperationsToscaUtilTest { Assert.assertFalse(mainYaml.contains("operations")); Assert.assertTrue(mainYaml.contains("resourceName:")); Assert.assertTrue(mainYaml.contains("inputs:")); - validateOperationInputs(mainYaml); + validateOperationInputs(mainYaml, 2, null); Assert.assertFalse(mainYaml.contains("defaultp")); Assert.assertTrue(mainYaml.contains("has description")); Assert.assertTrue(mainYaml.contains(MAPPED_PROPERTY_NAME)); @@ -141,12 +150,12 @@ public class InterfacesOperationsToscaUtilTest { component.setNormalizedName("normalizedServiceComponentName"); InterfaceDefinition addedInterface = new InterfaceDefinition(); addedInterface.setType("com.some.service.or.other.serviceName"); - addOperationsToInterface(addedInterface, 3, 2, true); + addOperationsToInterface(component, addedInterface, 3, 2, true, false); final String interfaceType = "normalizedServiceComponentName-interface"; component.setInterfaces(new HashMap<>()); component.getInterfaces().put(interfaceType, addedInterface); ToscaNodeType nodeType = new ToscaNodeType(); - InterfacesOperationsToscaUtil.addInterfaceDefinitionElement(component, nodeType, false); + addInterfaceDefinitionElement(component, nodeType, false); ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null); ToscaTemplate template = new ToscaTemplate("testService"); @@ -158,7 +167,7 @@ public class InterfacesOperationsToscaUtilTest { Assert.assertFalse(mainYaml.contains("operations")); Assert.assertTrue(mainYaml.contains("serviceName:")); Assert.assertTrue(mainYaml.contains("inputs:")); - validateOperationInputs(mainYaml); + validateOperationInputs(mainYaml, 2, null); Assert.assertFalse(mainYaml.contains("defaultp")); Assert.assertTrue(mainYaml.contains("has description")); Assert.assertTrue(mainYaml.contains(MAPPED_PROPERTY_NAME)); @@ -171,12 +180,12 @@ public class InterfacesOperationsToscaUtilTest { component.setNormalizedName("normalizedComponentName"); InterfaceDefinition addedInterface = new InterfaceDefinition(); addedInterface.setType("com.some.resource.or.other.resourceNameNoInputs"); - addOperationsToInterface(addedInterface, 3, 3, false); + addOperationsToInterface(component, addedInterface, 3, 3, false, false); final String interfaceType = "normalizedComponentName-interface"; component.setInterfaces(new HashMap<>()); component.getInterfaces().put(interfaceType, addedInterface); ToscaNodeType nodeType = new ToscaNodeType(); - InterfacesOperationsToscaUtil.addInterfaceDefinitionElement(component, nodeType, false); + addInterfaceDefinitionElement(component, nodeType, false); ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null); ToscaTemplate template = new ToscaTemplate("test"); @@ -193,9 +202,42 @@ public class InterfacesOperationsToscaUtilTest { Assert.assertTrue(toscaRepresentation.getMainYaml().contains("com.some.resource.or.other.resourceName")); } + @Test + public void addInterfaceDefinitionElementInputMappedToOtherOperationOutput() { + String addedInterfaceType = "com.some.resource.or.other.resourceNameInputMappedToOutput"; + Component component = new Resource(); + component.setNormalizedName("normalizedComponentName"); + InterfaceDefinition addedInterface = new InterfaceDefinition(); + addedInterface.setType(addedInterfaceType); + addOperationsToInterface(component, addedInterface, 2, 2, true, true); + addedInterface.getOperationsMap().values().stream() + .filter(operationInputDefinition -> operationInputDefinition.getName().equalsIgnoreCase( + "name_for_op_0")) + .forEach(operation -> operation.getInputs().getListToscaDataDefinition().stream() + .filter(operationInputDefinition -> operationInputDefinition.getName().contains("integer")) + .forEach(operationInputDefinition -> operationInputDefinition.setInputId(addedInterfaceType + + ".name_for_op_1.output_integer_1"))); + component.setInterfaces(new HashMap<>()); + component.getInterfaces().put(addedInterfaceType, addedInterface); + ToscaNodeType nodeType = new ToscaNodeType(); + addInterfaceDefinitionElement(component, nodeType, false); + + ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null); + ToscaTemplate template = new ToscaTemplate("test"); + Map<String, ToscaNodeType> nodeTypes = new HashMap<>(); + nodeTypes.put("test", nodeType); + template.setNode_types(nodeTypes); + final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template); + + String mainYaml = toscaRepresentation.getMainYaml(); + Assert.assertFalse(mainYaml.contains("operations")); + Assert.assertTrue(mainYaml.contains("resourceNameInputMappedToOutput:")); + Assert.assertTrue(mainYaml.contains("inputs:")); + validateOperationInputs(mainYaml, 2, "name_for_op_1"); + } - private void addOperationsToInterface(InterfaceDefinition addedInterface, int numOfOps, int numOfInputsPerOp, - boolean hasInputs) { + private void addOperationsToInterface(Component component, InterfaceDefinition addedInterface, int numOfOps, + int numOfInputsPerOp, boolean hasInputs, boolean hasOutputs) { addedInterface.setOperations(new HashMap<>()); for (int i = 0; i < numOfOps; i++) { @@ -206,23 +248,46 @@ public class InterfacesOperationsToscaUtilTest { implementation.setArtifactName(i + "_createBPMN.bpmn"); operation.setImplementation(implementation); if (hasInputs) { - operation.setInputs(createInputs(numOfInputsPerOp)); + operation.setInputs(createInputs(component, numOfInputsPerOp)); + } + if (hasOutputs) { + operation.setOutputs(createOutputs(numOfInputsPerOp)); } addedInterface.getOperations().put(operation.getName(), operation); } } - private ListDataDefinition<OperationInputDefinition> createInputs(int numOfInputs) { + private ListDataDefinition<OperationInputDefinition> createInputs(Component component, int numOfInputs) { ListDataDefinition<OperationInputDefinition> operationInputDefinitionList = new ListDataDefinition<>(); for (int i = 0; i < numOfInputs; i++) { + String mappedPropertyName = java.util.UUID.randomUUID().toString() + "." + MAPPED_PROPERTY_NAME + i; operationInputDefinitionList.add(createMockOperationInputDefinition( - INPUT_NAME_PREFIX + inputTypes[i] + "_" + i, - java.util.UUID.randomUUID().toString() + "." + MAPPED_PROPERTY_NAME, i)); + INPUT_NAME_PREFIX + inputTypes[i] + "_" + i, mappedPropertyName, i)); + addMappedPropertyAsComponentInput(component, mappedPropertyName); + } return operationInputDefinitionList; } + private void addMappedPropertyAsComponentInput(Component component, String mappedPropertyName) { + InputDefinition componentInput = new InputDefinition(); + componentInput.setUniqueId(mappedPropertyName.split("\\.")[0]); + componentInput.setName(mappedPropertyName.split("\\.")[1]); + if (Objects.isNull(component.getInputs())) { + component.setInputs(new ArrayList<>()); + } + component.getInputs().add(componentInput); + } + + private ListDataDefinition<OperationOutputDefinition> createOutputs(int numOfOutputs) { + ListDataDefinition<OperationOutputDefinition> operationOutputDefinitionList = new ListDataDefinition<>(); + for (int i = 0; i < numOfOutputs; i++) { + operationOutputDefinitionList.add(createMockOperationOutputDefinition( + OUTPUT_NAME_PREFIX + inputTypes[i] + "_" + i, i)); + } + return operationOutputDefinitionList; + } private OperationInputDefinition createMockOperationInputDefinition(String name, String id, int index) { OperationInputDefinition operationInputDefinition = new OperationInputDefinition(); @@ -233,31 +298,70 @@ public class InterfacesOperationsToscaUtilTest { return operationInputDefinition; } - private void validateOperationInputs(String mainYaml) { + private OperationOutputDefinition createMockOperationOutputDefinition(String name, int index) { + OperationOutputDefinition operationInputDefinition = new OperationOutputDefinition(); + operationInputDefinition.setName(name); + operationInputDefinition.setType(inputTypes[index]); + operationInputDefinition.setRequired(index % 2 == 0); + return operationInputDefinition; + } + + private void validateOperationInputs(String mainYaml, int numOfInputsPerOp, String mappedOperationName) { String nodeTypeKey = NODE_TYPE_NAME + ":"; String nodeTypesRepresentation = mainYaml.substring(mainYaml.indexOf(nodeTypeKey) + nodeTypeKey.length(), - mainYaml.lastIndexOf(MAPPED_PROPERTY_NAME) + MAPPED_PROPERTY_NAME.length()); + mainYaml.lastIndexOf(MAPPED_PROPERTY_NAME) + MAPPED_PROPERTY_NAME.length() + + String.valueOf(numOfInputsPerOp).length()); YamlToObjectConverter objectConverter = new YamlToObjectConverter(); ToscaNodeType toscaNodeType = objectConverter.convert(nodeTypesRepresentation.getBytes(), ToscaNodeType.class); Map<String, Object> interfaces = toscaNodeType.getInterfaces(); - for (Object interfaceVal : interfaces.values()) { - Map<String, Object> interfaceDefinition = mapper.convertValue(interfaceVal, Map.class); - for (Object operationVal : interfaceDefinition.values()) { + for (Map.Entry<String, Object> interfaceEntry : interfaces.entrySet()) { + Map<String, Object> interfaceDefinition = mapper.convertValue(interfaceEntry.getValue(), Map.class); + for (Map.Entry<String, Object> operationEntry : interfaceDefinition.entrySet()) { + Object operationVal = operationEntry.getValue(); if (operationVal instanceof Map) { - validateOperationInputDefinition(operationVal); + validateOperationInputDefinition((String) interfaceDefinition.get("type"), mappedOperationName, + operationVal); } } } } - private void validateOperationInputDefinition(Object operationVal) { - ToscaLifecycleOperationDefinition operation = - mapper.convertValue(operationVal, ToscaLifecycleOperationDefinition.class); - Map<String, ToscaProperty> inputs = operation.getInputs(); - for (Map.Entry<String, ToscaProperty> inputEntry : inputs.entrySet()) { - Assert.assertEquals(inputEntry.getKey().split("_")[1], inputEntry.getValue().getType()); - Boolean expectedIsRequired = Integer.parseInt(inputEntry.getKey().split("_")[2]) % 2 == 0; - Assert.assertEquals(expectedIsRequired, inputEntry.getValue().getRequired()); + private void validateOperationInputDefinition(String interfaceType, String operationName, Object operationVal) { + Map<String, Object> operation = mapper.convertValue(operationVal, Map.class); + Map<String, Object> inputs = (Map<String, Object>) operation.get("inputs"); + for (Map.Entry<String, Object> inputEntry : inputs.entrySet()) { + String[] inputNameSplit = inputEntry.getKey().split("_"); + Map<String, Object> inputValueObject = (Map<String, Object>) inputEntry.getValue(); + Assert.assertEquals(inputNameSplit[1], inputValueObject.get("type")); + Boolean expectedIsRequired = Integer.parseInt(inputNameSplit[2]) % 2 == 0; + Assert.assertEquals(expectedIsRequired, inputValueObject.get("required")); + validateOperationInputDefinitionDefaultValue(interfaceType, operationName, inputNameSplit[1], + Integer.parseInt(inputNameSplit[2]), inputValueObject); + } + } + + + private void validateOperationInputDefinitionDefaultValue(String interfaceType, String operationName, + String inputType, int index, + Map<String, Object> inputValueObject) { + Map<String, Object> mappedInputValue = (Map<String, Object>) inputValueObject.get("default"); + if(mappedInputValue.containsKey(GET_PROPERTY)) { + String mappedPropertyValue = MAPPED_PROPERTY_NAME + index; + List<String> mappedPropertyDefaultValue = (List<String>) mappedInputValue.get(GET_PROPERTY); + Assert.assertEquals(2, mappedPropertyDefaultValue.size()); + Assert.assertTrue(mappedPropertyDefaultValue.contains(SELF)); + Assert.assertTrue(mappedPropertyDefaultValue.contains(mappedPropertyValue)); + } else if(mappedInputValue.containsKey(GET_OPERATION_OUTPUT)) { + List<String> mappedPropertyDefaultValue = (List<String>) mappedInputValue.get(GET_OPERATION_OUTPUT); + Assert.assertEquals(4, mappedPropertyDefaultValue.size()); + String mappedPropertyValue = OUTPUT_NAME_PREFIX + inputType + "_" + index; + Assert.assertTrue(mappedPropertyDefaultValue.contains(SELF)); + Assert.assertTrue(mappedPropertyDefaultValue.contains(interfaceType)); + Assert.assertTrue(mappedPropertyDefaultValue.contains(operationName)); + Assert.assertTrue(mappedPropertyDefaultValue.contains(mappedPropertyValue)); + } else { + Assert.fail("Invalid Tosca function in default value. Allowed values: "+ GET_PROPERTY + + "/"+ GET_OPERATION_OUTPUT); } } } diff --git a/catalog-be/src/test/java/org/openecomp/sdc/test/utils/InterfaceOperationTestUtils.java b/catalog-be/src/test/java/org/openecomp/sdc/test/utils/InterfaceOperationTestUtils.java index f21d5a9dcf..c614c6e6e9 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/test/utils/InterfaceOperationTestUtils.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/test/utils/InterfaceOperationTestUtils.java @@ -18,6 +18,7 @@ package org.openecomp.sdc.test.utils; import java.util.HashMap; import java.util.Map; + import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition; import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition; import org.openecomp.sdc.be.datatypes.elements.OperationOutputDefinition; @@ -27,17 +28,6 @@ import org.openecomp.sdc.be.model.Operation; public class InterfaceOperationTestUtils { - public static Map<String, InterfaceDefinition> createMockInterfaceDefinitionMap(String interfaceId, - String operationId) { - Map<String, InterfaceDefinition> interfaceDefinitionMap = new HashMap<>(); - interfaceDefinitionMap.put(interfaceId, createMockInterface(interfaceId, operationId)); - return interfaceDefinitionMap; - } - - public static InterfaceDefinition createMockInterface(String interfaceId, String operationId) { - return createInterface(interfaceId, interfaceId, interfaceId, interfaceId, createMockOperationMap(operationId)); - } - private static InterfaceDefinition createInterface(String uniqueId, String description, String type, String toscaResourceName, Map<String, Operation> op) { InterfaceDefinition id = new InterfaceDefinition(); @@ -49,24 +39,37 @@ public class InterfaceOperationTestUtils { return id; } - public static Map<String, Operation> createMockOperationMap(String operationId) { + public static Map<String, InterfaceDefinition> createMockInterfaceDefinitionMap(String interfaceId, + String operationId, + String operationName) { + Map<String, InterfaceDefinition> interfaceDefinitionMap = new HashMap<>(); + interfaceDefinitionMap.put(interfaceId, createMockInterface(interfaceId, operationId, operationName)); + return interfaceDefinitionMap; + } + + public static InterfaceDefinition createMockInterface(String interfaceId, String operationId, String operationName) { + return createInterface(interfaceId, interfaceId, interfaceId, interfaceId, createMockOperationMap(operationId, + operationName)); + } + + public static Map<String, Operation> createMockOperationMap(String operationId, String operationName) { Map<String, Operation> operationMap = new HashMap<>(); - operationMap.put(operationId, createMockOperation(operationId)); + operationMap.put(operationId, createMockOperation(operationId, operationName)); return operationMap; } - public static Operation createMockOperation(String operationId) { + public static Operation createMockOperation(String operationId, String operationName) { Operation operation = new Operation(); ListDataDefinition<OperationInputDefinition> operationInputDefinitionList = new ListDataDefinition<>(); - operationInputDefinitionList.add(createMockOperationInputDefinition("inputId")); + operationInputDefinitionList.add(createMockOperationInputDefinition("Input1", 1)); operation.setInputs(operationInputDefinitionList); ListDataDefinition<OperationOutputDefinition> operationOutputDefList = new ListDataDefinition<>(); - operationOutputDefList.add(createMockOperationOutputDefinition("outputId")); + operationOutputDefList.add(createMockOperationOutputDefinition("Output1")); operation.setOutputs(operationOutputDefList); operation.setDefinition(false); - operation.setName(operationId); + operation.setName(operationName); operation.setUniqueId(operationId); ArtifactDefinition implementation = new ArtifactDefinition(); implementation.setUniqueId("uniqId"); @@ -77,23 +80,22 @@ public class InterfaceOperationTestUtils { return operation; } - public static OperationInputDefinition createMockOperationInputDefinition(String inputId) { + public static OperationInputDefinition createMockOperationInputDefinition(String inputName, int num) { OperationInputDefinition operationInputDefinition = new OperationInputDefinition(); - operationInputDefinition.setName(inputId); - operationInputDefinition.setUniqueId(inputId); - operationInputDefinition.setInputId(inputId); - operationInputDefinition.setValue(inputId); - operationInputDefinition.setDefaultValue(inputId); + operationInputDefinition.setName(inputName); + operationInputDefinition.setUniqueId(inputName + "_uniqueId"); + operationInputDefinition.setInputId("ComponentInput" + num + "_uniqueId"); + operationInputDefinition.setValue(inputName + "_value"); + operationInputDefinition.setDefaultValue(inputName + "_defaultValue"); return operationInputDefinition; } - public static OperationOutputDefinition createMockOperationOutputDefinition(String outputId) { + public static OperationOutputDefinition createMockOperationOutputDefinition(String outputName) { OperationOutputDefinition operationOutputDefinition = new OperationOutputDefinition(); - operationOutputDefinition.setName(outputId); - operationOutputDefinition.setUniqueId(outputId); - operationOutputDefinition.setInputId(outputId); - operationOutputDefinition.setValue(outputId); - operationOutputDefinition.setDefaultValue(outputId); + operationOutputDefinition.setName(outputName); + operationOutputDefinition.setUniqueId(outputName + "_uniqueId"); + operationOutputDefinition.setValue(outputName + "_value"); + operationOutputDefinition.setDefaultValue(outputName + "_defaultValue"); return operationOutputDefinition; } |