diff options
Diffstat (limited to 'catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance')
7 files changed, 758 insertions, 38 deletions
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstanceArtifactsMergeTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstanceArtifactsMergeTest.java index be16bc3621..df3e0ddb68 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstanceArtifactsMergeTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstanceArtifactsMergeTest.java @@ -1,10 +1,5 @@ package org.openecomp.sdc.be.components.merge.instance; -import static junit.framework.TestCase.assertEquals; - -import java.util.HashMap; -import java.util.Map; - import org.junit.Before; import org.junit.Test; import org.mockito.InjectMocks; @@ -14,6 +9,11 @@ import org.openecomp.sdc.be.model.Component; import org.openecomp.sdc.be.model.ComponentInstance; import org.openecomp.sdc.be.model.Resource; +import java.util.HashMap; +import java.util.Map; + +import static groovy.util.GroovyTestCase.assertEquals; + public class ComponentInstanceArtifactsMergeTest { diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstanceCapabiliteisPropertiesMergeTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstanceCapabiliteisPropertiesMergeTest.java new file mode 100644 index 0000000000..4fbb1ab5d7 --- /dev/null +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstanceCapabiliteisPropertiesMergeTest.java @@ -0,0 +1,70 @@ +package org.openecomp.sdc.be.components.merge.instance; + +import fj.data.Either; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; +import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.impl.ComponentsUtils; +import org.openecomp.sdc.be.model.CapabilityDefinition; +import org.openecomp.sdc.be.model.Component; +import org.openecomp.sdc.be.model.Resource; +import org.openecomp.sdc.be.model.Service; +import org.openecomp.sdc.be.model.User; +import org.openecomp.sdc.exception.ResponseFormat; + +import java.util.Collections; +import java.util.List; + +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.when; + +@RunWith(MockitoJUnitRunner.class) +public class ComponentInstanceCapabiliteisPropertiesMergeTest { + + @InjectMocks + private ComponentInstanceCapabiliteisPropertiesMerge testInstance; + + @Mock + private ComponentCapabilitiesPropertiesMergeBL capabilitiesPropertiesMergeBL; + + @Mock + private ComponentsUtils componentsUtils; + + private DataForMergeHolder mergeHolder; + + private Resource origInstanceNode; + private List<CapabilityDefinition> origInstanceCapabilities; + + @Before + public void setUp() throws Exception { + origInstanceNode = new Resource(); + origInstanceCapabilities = Collections.emptyList(); + mergeHolder = new DataForMergeHolder(); + mergeHolder.setOrigInstanceNode(origInstanceNode); + mergeHolder.setOrigInstanceCapabilities(origInstanceCapabilities); + } + + @Test + public void mergeDataAfterCreate() { + Service currentComponent = new Service(); + when(capabilitiesPropertiesMergeBL.mergeComponentInstanceCapabilities(currentComponent, origInstanceNode, "instId", origInstanceCapabilities)) + .thenReturn(ActionStatus.OK); + Either<Component, ResponseFormat> mergeResult = testInstance.mergeDataAfterCreate(new User(), mergeHolder, currentComponent, "instId"); + assertTrue(mergeResult.isLeft()); + } + + @Test + public void mergeDataAfterCreate_error() { + Service currentComponent = new Service(); + when(capabilitiesPropertiesMergeBL.mergeComponentInstanceCapabilities(currentComponent, origInstanceNode, "instId", origInstanceCapabilities)) + .thenReturn(ActionStatus.GENERAL_ERROR); + when(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR)).thenReturn(new ResponseFormat()); + Either<Component, ResponseFormat> mergeResult = testInstance.mergeDataAfterCreate(new User(), mergeHolder, currentComponent, "instId"); + assertTrue(mergeResult.isRight()); + } + +}
\ No newline at end of file diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstanceCapabilitiesMergeBLTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstanceCapabilitiesMergeBLTest.java new file mode 100644 index 0000000000..d73459c1b1 --- /dev/null +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstanceCapabilitiesMergeBLTest.java @@ -0,0 +1,275 @@ +package org.openecomp.sdc.be.components.merge.instance; + +import com.google.common.collect.ImmutableMap; +import fj.data.Either; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.junit.MockitoJUnitRunner; +import org.openecomp.sdc.be.auditing.impl.AuditingManager; +import org.openecomp.sdc.be.components.merge.capability.SimpleCapabilityResolver; +import org.openecomp.sdc.be.components.merge.property.DataDefinitionsValuesMergingBusinessLogic; +import org.openecomp.sdc.be.components.utils.CapabilityDefinitionBuilder; +import org.openecomp.sdc.be.components.utils.ComponentInstanceBuilder; +import org.openecomp.sdc.be.components.utils.ComponentInstancePropertyBuilder; +import org.openecomp.sdc.be.components.utils.ResourceBuilder; +import org.openecomp.sdc.be.config.ConfigurationManager; +import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.impl.ComponentsUtils; +import org.openecomp.sdc.be.model.CapabilityDefinition; +import org.openecomp.sdc.be.model.ComponentInstance; +import org.openecomp.sdc.be.model.ComponentInstanceProperty; +import org.openecomp.sdc.be.model.ComponentParametersView; +import org.openecomp.sdc.be.model.Resource; +import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.openecomp.sdc.common.api.ConfigurationSource; +import org.openecomp.sdc.common.impl.ExternalConfiguration; +import org.openecomp.sdc.common.impl.FSConfigurationSource; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; + +import static java.util.Collections.emptyMap; +import static java.util.Collections.singletonList; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.anyList; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.any; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoMoreInteractions; +import static org.mockito.Mockito.verifyZeroInteractions; +import static org.mockito.Mockito.when; + +@RunWith(MockitoJUnitRunner.class) +public class ComponentInstanceCapabilitiesMergeBLTest { + + private static final String INSTANCE1 = "inst1"; + private static final String INSTANCE2 = "inst2"; + + private ComponentCapabilitiesPropertiesMergeBL testInstance; + private ComponentsUtils componentsUtils; + @Mock + private SimpleCapabilityResolver capabilityResolver; + @Mock + private ToscaOperationFacade toscaOperationFacade; + @Mock + private DataDefinitionsValuesMergingBusinessLogic dataDefinitionsValuesMergingBusinessLogic; + @Captor + private ArgumentCaptor<List<ComponentInstanceProperty>> prevCapPropertiesCaptor; + @Captor + private ArgumentCaptor<List<ComponentInstanceProperty>> currCapPropertiesCaptor; + @Captor + private ArgumentCaptor<ComponentParametersView> getCurrResourceFilterCapture; + + private CapabilityDefinition oldCap; + private CapabilityDefinition oldCap2; + private CapabilityDefinition newCap; + private CapabilityDefinition newCap2; + + private ComponentParametersView getCapabilitiesPropsFilter; + + protected static ConfigurationManager configurationManager = null; + + @Before + public void setUp() throws Exception { + oldCap = new CapabilityDefinitionBuilder() + .setOwnerId(INSTANCE1) + .setOwnerName(INSTANCE1) + .setId("cap1") + .setType("type1") + .setName("cap1") + .addProperty(new ComponentInstancePropertyBuilder().setName("prop1").build()) + .addProperty(new ComponentInstancePropertyBuilder().setName("prop2").build()) + .build(); + + oldCap2 = new CapabilityDefinitionBuilder() + .setOwnerId(INSTANCE2) + .setOwnerName(INSTANCE2) + .setId("cap2") + .setType("type1") + .setName("cap2") + .addProperty(new ComponentInstancePropertyBuilder().setName("prop1").build()) + .build(); + + newCap = new CapabilityDefinitionBuilder() + .setOwnerId(INSTANCE1) + .setOwnerName(INSTANCE1) + .setId("cap1") + .setType("type1") + .setName("cap1") + .addProperty(new ComponentInstancePropertyBuilder().setName("prop1").build()) + .build(); + + newCap2 = new CapabilityDefinitionBuilder() + .setOwnerId(INSTANCE2) + .setOwnerName(INSTANCE2) + .setId("cap2") + .setType("type1") + .setName("cap2") + .addProperty(new ComponentInstancePropertyBuilder().setName("prop2").build()) + .addProperty(new ComponentInstancePropertyBuilder().setName("prop3").build()) + .build(); + + getCapabilitiesPropsFilter = new ComponentParametersView(); + getCapabilitiesPropsFilter.disableAll(); + getCapabilitiesPropsFilter.setIgnoreComponentInstances(false); + getCapabilitiesPropsFilter.setIgnoreCapabilities(false); + getCapabilitiesPropsFilter.setIgnoreCapabiltyProperties(false); + + ExternalConfiguration.setAppName("catalog-be"); + String appConfigDir = "src/test/resources/config/catalog-be"; + ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir); + ConfigurationManager configurationManager = new ConfigurationManager(configurationSource); + componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class)); + testInstance = new ComponentCapabilitiesPropertiesMergeBL(dataDefinitionsValuesMergingBusinessLogic, toscaOperationFacade, componentsUtils, capabilityResolver); + } + + @Test + public void mergeCapabilityProperties_singleCapability() { + ComponentInstance prevInst1 = new ComponentInstanceBuilder().addCapability(oldCap).setName(oldCap.getOwnerName()).build(); + ComponentInstance newInst1 = new ComponentInstanceBuilder().addCapability(newCap).setName(newCap.getOwnerName()).build(); + Resource prevResource = new ResourceBuilder().addComponentInstance(prevInst1).build(); + Resource newResource = new ResourceBuilder().addComponentInstance(newInst1).build(); + when(toscaOperationFacade.getToscaElement(eq(newResource.getUniqueId()), getCurrResourceFilterCapture.capture())).thenReturn(Either.left(newResource)); + when(capabilityResolver.resolvePrevCapIdToNewCapability(prevInst1, newInst1)).thenReturn(ImmutableMap.of(oldCap, newCap)); + when(toscaOperationFacade.updateComponentCalculatedCapabilitiesProperties(newResource)).thenReturn(StorageOperationStatus.OK); + + ActionStatus actionStatus = testInstance.mergeComponents(prevResource, newResource); + + assertThat(actionStatus).isEqualTo(ActionStatus.OK); + verify(dataDefinitionsValuesMergingBusinessLogic).mergeInstanceDataDefinitions(prevCapPropertiesCaptor.capture(), currCapPropertiesCaptor.capture()); + assertThat(prevCapPropertiesCaptor.getValue()).extracting("name").containsExactly("prop1", "prop2"); + assertThat(currCapPropertiesCaptor.getValue()).extracting("name").containsExactly("prop1"); + assertThat(getCurrResourceFilterCapture.getValue()).isEqualToComparingFieldByField(getCapabilitiesPropsFilter); + } + + @Test + public void mergeCapabilityProperties_failToGetResourceWithPropsCapabilities() { + Resource currResource = new ResourceBuilder().setUniqueId("rid").build(); + when(toscaOperationFacade.getToscaElement(eq(currResource.getUniqueId()), any(ComponentParametersView.class))).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND)); + ActionStatus actionStatus = testInstance.mergeComponents(new Resource(), currResource); + assertThat(actionStatus).isEqualTo(ActionStatus.RESOURCE_NOT_FOUND); + } + + @Test + public void mergeCapabilityProperties_multipleCapabilitiesToMerge() { + ComponentInstance prevInst1 = new ComponentInstanceBuilder().addCapability(oldCap).setName(oldCap.getOwnerName()).build(); + ComponentInstance prevInst2 = new ComponentInstanceBuilder().addCapability(oldCap2).setName(oldCap2.getOwnerName()).build(); + + ComponentInstance currInst1 = new ComponentInstanceBuilder().addCapability(newCap).setName(newCap.getOwnerName()).build(); + ComponentInstance currInst2 = new ComponentInstanceBuilder().addCapability(newCap2).setName(newCap2.getOwnerName()).build(); + + Resource currResource = new ResourceBuilder().addComponentInstance(currInst1).addComponentInstance(currInst2).build(); + Resource prevResource = new ResourceBuilder().addComponentInstance(prevInst1).addComponentInstance(prevInst2).build(); + when(toscaOperationFacade.getToscaElement(eq(currResource.getUniqueId()), any(ComponentParametersView.class))).thenReturn(Either.left(currResource)); + when(capabilityResolver.resolvePrevCapIdToNewCapability(prevInst1, currInst1)).thenReturn(ImmutableMap.of(oldCap, newCap)); + when(capabilityResolver.resolvePrevCapIdToNewCapability(prevInst2, currInst2)).thenReturn(ImmutableMap.of(oldCap2, newCap2)); + when(toscaOperationFacade.updateComponentCalculatedCapabilitiesProperties(currResource)).thenReturn(StorageOperationStatus.OK); + ActionStatus actionStatus = testInstance.mergeComponents(prevResource, currResource); + assertThat(actionStatus).isEqualTo(ActionStatus.OK); + verify(dataDefinitionsValuesMergingBusinessLogic, times(2)).mergeInstanceDataDefinitions(anyList(), anyList()); + } + + @Test + public void mergeCapabilityProperties_noNewCapabilitiesResolved() { + ComponentInstance prevInst1 = new ComponentInstanceBuilder().addCapability(oldCap).setName(oldCap.getOwnerName()).build(); + ComponentInstance newInst1 = new ComponentInstanceBuilder().setName(oldCap.getOwnerName()).build(); + Resource prevResource = new ResourceBuilder().addComponentInstance(prevInst1).build(); + Resource newResource = new ResourceBuilder().addComponentInstance(newInst1).build(); + when(toscaOperationFacade.getToscaElement(eq(newResource.getUniqueId()), any(ComponentParametersView.class))).thenReturn(Either.left(newResource)); + when(capabilityResolver.resolvePrevCapIdToNewCapability(prevInst1, newInst1)).thenReturn(emptyMap()); + when(toscaOperationFacade.updateComponentCalculatedCapabilitiesProperties(newResource)).thenReturn(StorageOperationStatus.OK); + ActionStatus actionStatus = testInstance.mergeComponents(prevResource, newResource); + assertThat(actionStatus).isEqualTo(ActionStatus.OK); + verifyZeroInteractions(dataDefinitionsValuesMergingBusinessLogic); + } + + @Test + public void mergeCapabilityProperties_noPrevCapabilitiesToMerge() { + Resource newResource = new Resource(); + Resource prevResource = new Resource(); + when(toscaOperationFacade.getToscaElement(eq(newResource.getUniqueId()), any(ComponentParametersView.class))).thenReturn(Either.left(newResource)); + verifyNoMoreInteractions(toscaOperationFacade); + ActionStatus actionStatus = testInstance.mergeComponents(prevResource, newResource); + assertThat(actionStatus).isEqualTo(ActionStatus.OK); + verifyZeroInteractions(dataDefinitionsValuesMergingBusinessLogic); + } + + @Test + public void mergeCapabilityProperties_failedToUpdateComponent() { + ComponentInstance inst1 = new ComponentInstanceBuilder().addCapability(oldCap).setName(oldCap.getOwnerName()).build(); + Resource newResource = new Resource(); + Resource prevResource = new ResourceBuilder().addComponentInstance(inst1).build(); + when(toscaOperationFacade.getToscaElement(eq(newResource.getUniqueId()), any(ComponentParametersView.class))).thenReturn(Either.left(newResource)); + when(toscaOperationFacade.updateComponentCalculatedCapabilitiesProperties(newResource)).thenReturn(StorageOperationStatus.GENERAL_ERROR); + ActionStatus actionStatus = testInstance.mergeComponents(prevResource, newResource); + assertThat(actionStatus).isEqualTo(ActionStatus.GENERAL_ERROR); + } + + //////////////////////////// + @Test + public void mergeInstanceCapabilityProperties_singleCap() { + List<CapabilityDefinition> previousInstanceCapabilities = Collections.singletonList(oldCap); + ComponentInstance inst1 = new ComponentInstanceBuilder().addCapability(newCap).setId(newCap.getOwnerId()).build(); + Resource container = new ResourceBuilder().addComponentInstance(inst1).build(); + Resource origInstanceNode = new Resource(); + when(toscaOperationFacade.updateComponentInstanceCapabilityProperties(container, newCap.getOwnerId())).thenReturn(StorageOperationStatus.OK); + when(capabilityResolver.resolvePrevCapToNewCapability(container, origInstanceNode, INSTANCE1, previousInstanceCapabilities)).thenReturn(ImmutableMap.of(oldCap, newCap)); + ActionStatus actionStatus = testInstance.mergeComponentInstanceCapabilities(container, origInstanceNode, INSTANCE1, previousInstanceCapabilities); + assertThat(actionStatus).isEqualTo(ActionStatus.OK); + verify(dataDefinitionsValuesMergingBusinessLogic).mergeInstanceDataDefinitions(prevCapPropertiesCaptor.capture(), currCapPropertiesCaptor.capture()); + + assertThat(prevCapPropertiesCaptor.getValue()).extracting("name").containsExactly("prop1", "prop2"); + assertThat(currCapPropertiesCaptor.getValue()).extracting("name").containsExactly("prop1"); + } + + @Test + public void mergeInstanceCapabilityProperties() { + List<CapabilityDefinition> previousInstanceCapabilities = Arrays.asList(oldCap, oldCap2); + ComponentInstance inst1 = new ComponentInstanceBuilder().addCapability(newCap).addCapability(newCap2).setId(newCap.getOwnerId()).build(); + Resource container = new ResourceBuilder().addComponentInstance(inst1).build(); + Resource origInstanceNode = new Resource(); + when(capabilityResolver.resolvePrevCapToNewCapability(container, origInstanceNode, INSTANCE1, previousInstanceCapabilities)).thenReturn(ImmutableMap.of(oldCap, newCap, oldCap2, newCap2)); + when(toscaOperationFacade.updateComponentInstanceCapabilityProperties(container, INSTANCE1)).thenReturn(StorageOperationStatus.OK); + ActionStatus actionStatus = testInstance.mergeComponentInstanceCapabilities(container, origInstanceNode, INSTANCE1, previousInstanceCapabilities); + assertThat(actionStatus).isEqualTo(ActionStatus.OK); + verify(dataDefinitionsValuesMergingBusinessLogic, times(2)).mergeInstanceDataDefinitions(anyList(), anyList()); + } + + @Test + public void mergeInstanceCapabilityProperties_emptyCapabilitiesList() { + ActionStatus actionStatus = testInstance.mergeComponentInstanceCapabilities(new Resource(), new Resource(), "instanceId", Collections.emptyList()); + assertThat(actionStatus).isEqualTo(ActionStatus.OK); + verifyZeroInteractions(toscaOperationFacade, dataDefinitionsValuesMergingBusinessLogic, capabilityResolver); + } + + @Test + public void mergeInstanceCapabilityProperties_failedToUpdateComponent() { + Resource container = new Resource(); + Resource resource = new Resource(); + List<CapabilityDefinition> capList = singletonList(oldCap); + when(capabilityResolver.resolvePrevCapToNewCapability(container, resource, INSTANCE1, capList)).thenReturn(ImmutableMap.of(oldCap, newCap)); + when(toscaOperationFacade.updateComponentInstanceCapabilityProperties(container, INSTANCE1)).thenReturn(StorageOperationStatus.GENERAL_ERROR); + ActionStatus actionStatus = testInstance.mergeComponentInstanceCapabilities(container, resource, INSTANCE1, capList); + assertThat(actionStatus).isEqualTo(ActionStatus.GENERAL_ERROR); + } + + @Test + public void mergeInstanceCapabilityProperties_noNewCapabilitiesFound() { + Resource container = new Resource(); + Resource resource = new Resource(); + List<CapabilityDefinition> prevCapabilities = singletonList(oldCap); + when(capabilityResolver.resolvePrevCapToNewCapability(container, resource, INSTANCE1, prevCapabilities)).thenReturn(emptyMap()); + when(toscaOperationFacade.updateComponentInstanceCapabilityProperties(container, INSTANCE1)).thenReturn(StorageOperationStatus.OK); + ActionStatus actionStatus = testInstance.mergeComponentInstanceCapabilities(container, resource, INSTANCE1, prevCapabilities); + assertThat(actionStatus).isEqualTo(ActionStatus.OK); + verifyZeroInteractions(dataDefinitionsValuesMergingBusinessLogic); + } +}
\ No newline at end of file diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstanceHeatEnvMergeTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstanceHeatEnvMergeTest.java index 2101ea49ab..115825733e 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstanceHeatEnvMergeTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstanceHeatEnvMergeTest.java @@ -1,13 +1,6 @@ package org.openecomp.sdc.be.components.merge.instance; -import static org.mockito.Mockito.when; - -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.stream.Collectors; -import java.util.stream.Stream; - +import fj.data.Either; import org.junit.Before; import org.junit.Test; import org.mockito.InjectMocks; @@ -26,7 +19,13 @@ import org.openecomp.sdc.be.model.User; import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum; import org.openecomp.sdc.common.api.ArtifactTypeEnum; -import fj.data.Either; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import static org.mockito.Mockito.when; public class ComponentInstanceHeatEnvMergeTest { @@ -67,7 +66,7 @@ public class ComponentInstanceHeatEnvMergeTest { for (ArtifactDefinition mergedArtifact : mergedArtifacts) { Map<String, Object> json = new HashMap<>(); when(artifactsBusinessLogicMock.buildJsonForUpdateArtifact(mergedArtifact, ArtifactGroupTypeEnum.DEPLOYMENT, null)).thenReturn(json); - ArtifactsBusinessLogic.ArtifactOperationInfo artifactUpdateOperation = artifactsBusinessLogicMock.new ArtifactOperationInfo(false, false, ArtifactsBusinessLogic.ArtifactOperationEnum.Update); + ArtifactsBusinessLogic.ArtifactOperationInfo artifactUpdateOperation = artifactsBusinessLogicMock.new ArtifactOperationInfo(false, false, ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE); when(artifactsBusinessLogicMock.updateResourceInstanceArtifactNoContent(Mockito.eq(instanceId), Mockito.eq(resource), Mockito.eq(USER), Mockito.eq(json), Mockito.refEq(artifactUpdateOperation), diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstanceMergeDataBusinessLogicTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstanceMergeDataBusinessLogicTest.java index bc3efe423d..630a43ef2d 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstanceMergeDataBusinessLogicTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstanceMergeDataBusinessLogicTest.java @@ -1,13 +1,6 @@ package org.openecomp.sdc.be.components.merge.instance; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyZeroInteractions; -import static org.mockito.Mockito.when; - -import java.util.Arrays; - +import fj.data.Either; import org.junit.Before; import org.junit.Test; import org.mockito.ArgumentCaptor; @@ -29,7 +22,13 @@ import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; import org.openecomp.sdc.exception.ResponseFormat; -import fj.data.Either; +import java.util.Arrays; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyZeroInteractions; +import static org.mockito.Mockito.when; public class ComponentInstanceMergeDataBusinessLogicTest { @@ -112,4 +111,6 @@ public class ComponentInstanceMergeDataBusinessLogicTest { assertFalse(value.isIgnoreArtifacts()); } + + }
\ No newline at end of file diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstancePropsAndInputsMergeTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstancePropsAndInputsMergeTest.java index cb3d506bfc..d946206f23 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstancePropsAndInputsMergeTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstancePropsAndInputsMergeTest.java @@ -1,16 +1,6 @@ package org.openecomp.sdc.be.components.merge.instance; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.anyList; -import static org.mockito.ArgumentMatchers.anyListOf; -import static org.mockito.ArgumentMatchers.anyString; -import static org.mockito.Mockito.verifyZeroInteractions; -import static org.mockito.Mockito.when; - -import java.util.List; - +import fj.data.Either; import org.junit.Before; import org.junit.Test; import org.mockito.ArgumentCaptor; @@ -19,8 +9,6 @@ import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.MockitoAnnotations; import org.openecomp.sdc.be.components.merge.input.ComponentInputsMergeBL; -import org.openecomp.sdc.be.components.merge.property.ComponentInstanceInputsMergeBL; -import org.openecomp.sdc.be.components.merge.property.ComponentInstancePropertiesMergeBL; import org.openecomp.sdc.be.components.utils.ObjectGenerator; import org.openecomp.sdc.be.components.utils.ResourceBuilder; import org.openecomp.sdc.be.dao.api.ActionStatus; @@ -37,7 +25,16 @@ import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; import org.openecomp.sdc.exception.ResponseFormat; -import fj.data.Either; +import java.util.List; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.mockito.ArgumentMatchers.anyList; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.anyListOf; +import static org.mockito.Matchers.anyString; +import static org.mockito.Mockito.verifyZeroInteractions; +import static org.mockito.Mockito.when; public class ComponentInstancePropsAndInputsMergeTest { diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstanceRelationMergeTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstanceRelationMergeTest.java new file mode 100644 index 0000000000..08c8456064 --- /dev/null +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/instance/ComponentInstanceRelationMergeTest.java @@ -0,0 +1,378 @@ +package org.openecomp.sdc.be.components.merge.instance; + +import fj.data.Either; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.junit.MockitoJUnitRunner; +import org.openecomp.sdc.be.components.merge.utils.MergeInstanceUtils; +import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; +import org.openecomp.sdc.be.model.CapabilityDefinition; +import org.openecomp.sdc.be.model.CapabilityRequirementRelationship; +import org.openecomp.sdc.be.model.Component; +import org.openecomp.sdc.be.model.ComponentInstance; +import org.openecomp.sdc.be.model.RelationshipImpl; +import org.openecomp.sdc.be.model.RelationshipInfo; +import org.openecomp.sdc.be.model.RequirementCapabilityRelDef; +import org.openecomp.sdc.be.model.RequirementDefinition; +import org.openecomp.sdc.be.model.Resource; +import org.openecomp.sdc.be.model.Service; +import org.openecomp.sdc.be.model.User; +import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.stream.IntStream; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +@RunWith(MockitoJUnitRunner.class) +public class ComponentInstanceRelationMergeTest { + private ComponentInstanceRelationMerge compInstanceRelationMerge; + @Mock + private DataForMergeHolder dataHolder; + private Component containerComponent; + private Component updatedContainerComponent; + private ComponentInstance currentResourceInstance; + + private RequirementCapabilityRelDef requirementDef1; + private RequirementCapabilityRelDef requirementDef2; + private RequirementCapabilityRelDef capabilityDef1; + private RequirementCapabilityRelDef capabilityDef2; + + @Mock + private ToscaOperationFacade toscaOperationFacade; + + @Mock + private User user; + + @Captor + ArgumentCaptor<VfRelationsMergeInfo> argumentCaptor; + + + @Before + public void startUp() { + compInstanceRelationMerge = new ComponentInstanceRelationMerge(); + compInstanceRelationMerge.setToscaOperationFacade(toscaOperationFacade); + + MergeInstanceUtils mergeInstanceUtils = new MergeInstanceUtils(); + mergeInstanceUtils.setToscaOperationFacade(toscaOperationFacade); + compInstanceRelationMerge.setMergeInstanceUtils(mergeInstanceUtils); + + containerComponent = new Service(); + List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>(); + + requirementDef1 = createRequirementDef("SRV1.VF1.VFI_1", "SRV1.VF2.VFI_1", "SRV1.VF1.VFC_1.VFCI_1", "Requirement1"); + resourceInstancesRelations.add(requirementDef1); + requirementDef2 = createRequirementDef("SRV1.VF1.VFI_1", "SRV1.VF3.VFI_1", "SRV1.VF1.VFC_2.VFCI_2", "Requirement2"); + resourceInstancesRelations.add(requirementDef2); + + + capabilityDef1 = createCapabilityDef("SRV1.VF4.VFI_1", "SRV1.VF1.VFI_1", "SRV1.VF1.VFC_3.VFCI_3", "Capability3"); + resourceInstancesRelations.add(capabilityDef1); + capabilityDef2 = createCapabilityDef("SRV1.VF5.VFI_1", "SRV1.VF1.VFI_1", "SRV1.VF1.VFC_4.VFCI_1", "Capability4"); + resourceInstancesRelations.add(capabilityDef2); + + containerComponent.setComponentInstancesRelations(resourceInstancesRelations ); + + currentResourceInstance = new ComponentInstance(); + currentResourceInstance.setUniqueId("SRV1.VF1.VFI_1"); + currentResourceInstance.setComponentUid("SRV1.VF1"); + currentResourceInstance.setIsProxy(false); + + updatedContainerComponent = new Service(); + updatedContainerComponent.setUniqueId("123123123123123123"); + } + + @Test + public void testSaveDataBeforeMerge() { + Resource vf = new Resource(); + + List<ComponentInstance> vfcInstances = new ArrayList<>(); + vfcInstances.add(createVfci("vfc_A", "SRV1.VF1.VFC_1.VFCI_1", "SRV1.VF1.VFC_1", true)); + vfcInstances.add(createVfci("vfc_B", "SRV1.VF1.VFC_2.VFCI_2", "SRV1.VF1.VFC_2", true)); + vfcInstances.add(createVfci("vfc_C", "SRV1.VF1.VFC_3.VFCI_3", "SRV1.VF1.VFC_3", false)); + vfcInstances.add(createVfci("vfc_D", "SRV1.VF1.VFC_4.VFCI_1", "SRV1.VF1.VFC_4", true)); + vf.setComponentInstances(vfcInstances); + vf.setComponentType(ComponentTypeEnum.RESOURCE); + vf.setResourceType(ResourceTypeEnum.VF); + + compInstanceRelationMerge.saveDataBeforeMerge(dataHolder, containerComponent, currentResourceInstance, vf); + + verify(dataHolder).setVfRelationsInfo(argumentCaptor.capture()); + VfRelationsMergeInfo relationsMergeInfo = argumentCaptor.getValue(); + List<RelationMergeInfo> fromRelationsMergeInfo = relationsMergeInfo.getFromRelationsInfo(); + List<RelationMergeInfo> toRelationsMergeInfo = relationsMergeInfo.getToRelationsInfo(); + + assertNotNull("Expected not null list of relations merge info", fromRelationsMergeInfo); + assertNotNull("Expected not null list of relations merge info", toRelationsMergeInfo); + + assertEquals("Expected 2 elements", 2, fromRelationsMergeInfo.size()); + assertEquals("Expected 1 elements", 1, toRelationsMergeInfo.size()); + } + + @Test + public void testMergeDataAfterCreate_NoSavedData() { + compInstanceRelationMerge.mergeDataAfterCreate(user, dataHolder, updatedContainerComponent, "SRV1.VF1.VFI_2"); + + verify(dataHolder).getVfRelationsMergeInfo(); + List<RequirementCapabilityRelDef> relations = updatedContainerComponent.getComponentInstancesRelations(); + assertNull("Expected no relations", relations); + } + + @Test + public void testMergeDataAfterCreate() { + Resource vf = new Resource(); + + List<ComponentInstance> vfcInstances = new ArrayList<>(); + vfcInstances.add(createVfci("vfc_A", "SRV1.VF1.VFC_1.VFCI_1", "SRV1.VF1.VFC_1", true)); + vfcInstances.add(createVfci("vfc_B", "SRV1.VF1.VFC_2.VFCI_2", "SRV1.VF1.VFC_2", true)); + vfcInstances.add(createVfci("vfc_C", "SRV1.VF1.VFC_3.VFCI_3", "SRV1.VF1.VFC_3", false)); + vfcInstances.add(createVfci("vfc_D", "SRV1.VF1.VFC_4.VFCI_1", "SRV1.VF1.VFC_4", true)); + vf.setComponentInstances(vfcInstances); + vf.setComponentType(ComponentTypeEnum.RESOURCE); + vf.setResourceType(ResourceTypeEnum.VF); + + Either<Component, StorageOperationStatus> eitherVF = Either.left(vf); + when(toscaOperationFacade.getToscaElement("SRV1.VF1")).thenReturn(eitherVF); + + + List<RelationMergeInfo> fromRelationsMergeInfo = new ArrayList<>(); + List<RelationMergeInfo> toRelationsMergeInfo = new ArrayList<>(); + + RelationMergeInfo relationMergeInfo1 = new RelationMergeInfo("CapabilityType1", "capabilityA", "vfc_A", requirementDef1); + fromRelationsMergeInfo.add(relationMergeInfo1); + RelationMergeInfo relationMergeInfo2 = new RelationMergeInfo("CapabilityType4", "capabilityD", "vfc_D", capabilityDef2); + toRelationsMergeInfo.add(relationMergeInfo2); + + VfRelationsMergeInfo relationsMergeInfo = new VfRelationsMergeInfo(fromRelationsMergeInfo, toRelationsMergeInfo); + + when(dataHolder.getVfRelationsMergeInfo()).thenReturn(relationsMergeInfo); + + List<ComponentInstance> componentInstances = new ArrayList<>(); + componentInstances.add(createVfi("SRV1.VF1", "SRV1.VF1.VFI_2")); + componentInstances.add(createVfi("SRV1.VF2", "SRV1.VF2.VFI_1")); + componentInstances.add(createVfi("SRV1.VF3", "SRV1.VF3.VFI_1")); + componentInstances.add(createVfi("SRV1.VF4", "SRV1.VF4.VFI_1")); + componentInstances.add(createVfi("SRV1.VF5", "SRV1.VF5.VFI_1")); + updatedContainerComponent.setComponentInstances(componentInstances); + + List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>(); + updatedContainerComponent.setComponentInstancesRelations(resourceInstancesRelations); + + when(toscaOperationFacade.associateResourceInstances(Mockito.anyString(), Mockito.anyList())).thenReturn(StorageOperationStatus.OK); + + compInstanceRelationMerge.mergeDataAfterCreate(user, dataHolder, updatedContainerComponent, "SRV1.VF1.VFI_2"); + + verify(dataHolder).getVfRelationsMergeInfo(); + verify(toscaOperationFacade).associateResourceInstances(Mockito.anyString(), Mockito.anyList()); + + List<RequirementCapabilityRelDef> relations = updatedContainerComponent.getComponentInstancesRelations(); + assertEquals("Expected 2 relations", 2, relations.size()); + + + RequirementCapabilityRelDef capabilityRelDef = relations.get(0); + assertEquals("SRV1.VF1.VFC_4.VFCI_1", capabilityRelDef.resolveSingleRelationship().getRelation().getCapabilityOwnerId()); + assertEquals("SRV1.VF5.VFI_1", capabilityRelDef.getFromNode()); + assertEquals("SRV1.VF1.VFI_2", capabilityRelDef.getToNode()); + + RequirementCapabilityRelDef requirementRelDef = relations.get(1); + assertEquals("SRV1.VF1.VFC_1.VFCI_1", requirementRelDef.resolveSingleRelationship().getRelation().getRequirementOwnerId()); + assertEquals("SRV1.VF1.VFI_2", requirementRelDef.getFromNode()); + assertEquals("SRV1.VF2.VFI_1", requirementRelDef.getToNode()); + } + + + + @Test + public void testMergeDataAfterCreate_OwnerChanged() { + Resource vf = new Resource(); + + List<ComponentInstance> vfcInstances = new ArrayList<>(); + vfcInstances.add(createVfci("vfc_A", "SRV1.VF1.VFC_1.VFCI_2", "SRV1.VF1.VFC_1", true)); + vfcInstances.add(createVfci("vfc_B", "SRV1.VF1.VFC_2.VFCI_2", "SRV1.VF1.VFC_2", true)); + vfcInstances.add(createVfci("vfc_C", "SRV1.VF1.VFC_3.VFCI_3", "SRV1.VF1.VFC_3", false)); + vfcInstances.add(createVfci("vfc_D", "SRV1.VF1.VFC_4.VFCI_2", "SRV1.VF1.VFC_4", true)); + vf.setComponentInstances(vfcInstances); + vf.setComponentType(ComponentTypeEnum.RESOURCE); + vf.setResourceType(ResourceTypeEnum.VF); + + Either<Component, StorageOperationStatus> eitherVF = Either.left(vf); + when(toscaOperationFacade.getToscaElement("SRV1.VF1")).thenReturn(eitherVF); + + + List<RelationMergeInfo> fromRelationsMergeInfo = new ArrayList<>(); + List<RelationMergeInfo> toRelationsMergeInfo = new ArrayList<>(); + + RelationMergeInfo relationMergeInfo1 = new RelationMergeInfo("CapabilityType1", "capabilityA", "vfc_A", requirementDef1); + fromRelationsMergeInfo.add(relationMergeInfo1); + RelationMergeInfo relationMergeInfo2 = new RelationMergeInfo("CapabilityType4", "capabilityD", "vfc_D", capabilityDef2); + toRelationsMergeInfo.add(relationMergeInfo2); + + VfRelationsMergeInfo relationsMergeInfo = new VfRelationsMergeInfo(fromRelationsMergeInfo, toRelationsMergeInfo); + + when(dataHolder.getVfRelationsMergeInfo()).thenReturn(relationsMergeInfo); + + List<ComponentInstance> componentInstances = new ArrayList<>(); + componentInstances.add(createVfi("SRV1.VF1", "SRV1.VF1.VFI_2")); + componentInstances.add(createVfi("SRV1.VF2", "SRV1.VF2.VFI_1")); + componentInstances.add(createVfi("SRV1.VF3", "SRV1.VF3.VFI_1")); + componentInstances.add(createVfi("SRV1.VF4", "SRV1.VF4.VFI_1")); + componentInstances.add(createVfi("SRV1.VF5", "SRV1.VF5.VFI_1")); + updatedContainerComponent.setComponentInstances(componentInstances); + + List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>(); + updatedContainerComponent.setComponentInstancesRelations(resourceInstancesRelations); + + when(toscaOperationFacade.associateResourceInstances(Mockito.anyString(), Mockito.anyList())).thenReturn(StorageOperationStatus.OK); + + compInstanceRelationMerge.mergeDataAfterCreate(user, dataHolder, updatedContainerComponent, "SRV1.VF1.VFI_2"); + + verify(dataHolder).getVfRelationsMergeInfo(); + verify(toscaOperationFacade).associateResourceInstances(Mockito.anyString(), Mockito.anyList()); + + List<RequirementCapabilityRelDef> relations = updatedContainerComponent.getComponentInstancesRelations(); + assertEquals("Expected 2 relations", 2, relations.size()); + + + RequirementCapabilityRelDef capabilityRelDef = relations.get(0); + assertEquals("SRV1.VF1.VFC_4.VFCI_2", capabilityRelDef.resolveSingleRelationship().getRelation().getCapabilityOwnerId()); + assertEquals("SRV1.VF5.VFI_1", capabilityRelDef.getFromNode()); + assertEquals("SRV1.VF1.VFI_2", capabilityRelDef.getToNode()); + + RequirementCapabilityRelDef requirementRelDef = relations.get(1); + assertEquals("SRV1.VF1.VFC_1.VFCI_2", requirementRelDef.resolveSingleRelationship().getRelation().getRequirementOwnerId()); + assertEquals("SRV1.VF1.VFI_2", requirementRelDef.getFromNode()); + assertEquals("SRV1.VF2.VFI_1", requirementRelDef.getToNode()); + } + + + /** + * @param vfId + * @param vfiUniqueId + * @return + */ + private ComponentInstance createVfi(String vfId, String vfiUniqueId) { + ComponentInstance vfi = new ComponentInstance(); + vfi.setUniqueId(vfiUniqueId); + vfi.setComponentUid(vfId); + + Resource vf = new Resource(); + vf.setUniqueId(vfId); + return vfi; + } + + private ComponentInstance createVfci(String name, String uniqueId, String componentUid, boolean foundVfc) { + ComponentInstance compInst = new ComponentInstance(); + compInst.setName(name); + compInst.setUniqueId(uniqueId); + compInst.setComponentUid(componentUid); + + if(foundVfc) { + createVfc(componentUid); + } + else { + failLoadVfc(componentUid); + } + return compInst; + } + + private void failLoadVfc(String uid) { + Either<Component, StorageOperationStatus> eitherVFC = Either.right(StorageOperationStatus.NOT_FOUND); + when(toscaOperationFacade.getToscaElement(uid)).thenReturn(eitherVFC); + } + + private Component createVfc(String uid) { + Resource vfc = new Resource(); + vfc.setUniqueId(uid); + + Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>(); + Map<String, List<RequirementDefinition>> requirements = new HashMap<>();; + IntStream.range(0, 5).forEach(i -> { + + List<CapabilityDefinition> capList = new LinkedList<>(); + capList.add(null); + CapabilityDefinition capDef = new CapabilityDefinition(); + capDef.setName("CapabilityName" + i); + capDef.setUniqueId("Capability" + i); + capDef.setType("CapabilityType" + i); + capList.add(capDef); + capabilities.put("Key" + i, capList); + + List<RequirementDefinition> reqList = new LinkedList<>(); + reqList.add(null); + RequirementDefinition reqDef = new RequirementDefinition(); + reqDef.setName("RequirementName" + i); + reqDef.setUniqueId("Requirement" + i); + reqDef.setCapability("CapabilityType" + i); + reqList.add(reqDef); + requirements.put("Key" + i, reqList); + + }); + vfc.setCapabilities(capabilities ); + vfc.setRequirements(requirements); + + Either<Component, StorageOperationStatus> eitherVFC = Either.left(vfc); + when(toscaOperationFacade.getToscaElement(uid)).thenReturn(eitherVFC); + + return vfc; + } + + private RequirementCapabilityRelDef createRequirementCapabilityDef(String fromNode, String toNode) { + RequirementCapabilityRelDef reqCapDef = new RequirementCapabilityRelDef(); + + reqCapDef.setFromNode(fromNode); + reqCapDef.setToNode(toNode); + + List<CapabilityRequirementRelationship> relationships = new ArrayList<>(); + CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship(); + relationships.add(capabilityRequirementRelationship); + reqCapDef.setRelationships(relationships); + + return reqCapDef; + } + + private RequirementCapabilityRelDef createRequirementDef(String fromNode, String toNode, String ownerId, String requirementUid) { + RequirementCapabilityRelDef reqCapDef = createRequirementCapabilityDef(fromNode, toNode); + CapabilityRequirementRelationship capabilityRequirementRelationship = reqCapDef.resolveSingleRelationship(); + + RelationshipInfo relationshipInfo = new RelationshipInfo(); + relationshipInfo.setRequirementOwnerId(ownerId); + relationshipInfo.setRequirementUid(requirementUid); + relationshipInfo.setRelationships(new RelationshipImpl()); + capabilityRequirementRelationship.setRelation(relationshipInfo ); + + + + return reqCapDef; + } + + private RequirementCapabilityRelDef createCapabilityDef(String fromNode, String toNode, String ownerId, String capabilityUid) { + RequirementCapabilityRelDef reqCapDef = createRequirementCapabilityDef(fromNode, toNode); + CapabilityRequirementRelationship capabilityRequirementRelationship = reqCapDef.resolveSingleRelationship(); + + RelationshipInfo relationshipInfo = new RelationshipInfo(); + relationshipInfo.setCapabilityOwnerId(ownerId); + relationshipInfo.setCapabilityUid(capabilityUid); + relationshipInfo.setRelationships(new RelationshipImpl()); + capabilityRequirementRelationship.setRelation(relationshipInfo ); + + return reqCapDef; + } + + + +} |