From 8fea9935b3dd4a020bcfdd7cea3125b8f90edad0 Mon Sep 17 00:00:00 2001 From: talig Date: Thu, 13 Feb 2020 09:02:47 +0200 Subject: Fix PropertyConvertor initialization (use spring) refactor static InterfacesOperationsToscaUtil to be non-static InterfacesOperationsConverter (as it uses PropertyConvertor), move logic from static ToscaExportUtils to ToscaExportHandler (as it uses PropertyConvertor) Change-Id: I917351ca59ee1e792c7b0850d6a8b246b71b4b03 Issue-ID: SDC-2765 Signed-off-by: talig --- .../components/impl/utils/PropertiesUtilsTest.java | 1 - .../PropertyDataValueMergeBusinessLogicTest.java | 33 +- .../tosca/CapabilityRequirementConverterTest.java | 11 + .../sdc/be/tosca/GroupExportParserImplTest.java | 8 +- .../tosca/InputAnnotationConvertToToscaTest.java | 8 +- .../sdc/be/tosca/PolicyExportParserImplTest.java | 9 +- .../sdc/be/tosca/PropertyConvertorTest.java | 68 +-- .../sdc/be/tosca/ToscaExportHandlerTest.java | 164 ++++++ .../sdc/be/tosca/ToscaExportUtilsTest.java | 198 -------- .../utils/InterfacesOperationsConverterTest.java | 552 +++++++++++++++++++++ .../utils/InterfacesOperationsToscaUtilTest.java | 543 -------------------- 11 files changed, 795 insertions(+), 800 deletions(-) delete mode 100644 catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportUtilsTest.java create mode 100644 catalog-be/src/test/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsConverterTest.java delete mode 100644 catalog-be/src/test/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsToscaUtilTest.java (limited to 'catalog-be/src/test/java/org') diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/utils/PropertiesUtilsTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/utils/PropertiesUtilsTest.java index d038381c21..8789b15be0 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/utils/PropertiesUtilsTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/utils/PropertiesUtilsTest.java @@ -14,7 +14,6 @@ * limitations under the License. */ package org.openecomp.sdc.be.components.impl.utils; - import org.junit.Assert; import org.junit.Test; import org.junit.runner.RunWith; diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/property/PropertyDataValueMergeBusinessLogicTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/property/PropertyDataValueMergeBusinessLogicTest.java index def3f8cc69..bded51db11 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/property/PropertyDataValueMergeBusinessLogicTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/merge/property/PropertyDataValueMergeBusinessLogicTest.java @@ -20,10 +20,24 @@ package org.openecomp.sdc.be.components.merge.property; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.when; + import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; import com.google.common.collect.Maps; import fj.data.Either; +import java.io.IOException; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.function.Function; +import java.util.stream.Collectors; +import java.util.stream.Stream; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; @@ -37,21 +51,7 @@ import org.openecomp.sdc.be.model.DataTypeDefinition; import org.openecomp.sdc.be.model.PropertyDefinition; import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache; import org.openecomp.sdc.be.model.tosca.ToscaPropertyType; - -import java.io.IOException; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.function.Function; -import java.util.stream.Collectors; -import java.util.stream.Stream; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; -import static org.mockito.Mockito.when; +import org.openecomp.sdc.be.tosca.PropertyConvertor; @RunWith(MockitoJUnitRunner.class) public class PropertyDataValueMergeBusinessLogicTest { @@ -67,7 +67,8 @@ public class PropertyDataValueMergeBusinessLogicTest { public void setUp() throws Exception { PropertyValueMerger propertyValueMerger = new PropertyValueMerger(); - testInstance = new PropertyDataValueMergeBusinessLogic(propertyValueMerger, applicationDataTypeCache); + testInstance = new PropertyDataValueMergeBusinessLogic(propertyValueMerger, applicationDataTypeCache, + new PropertyConvertor()); } @Test diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/CapabilityRequirementConverterTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/CapabilityRequirementConverterTest.java index 5d6c98209c..5254c08dab 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/CapabilityRequirementConverterTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/CapabilityRequirementConverterTest.java @@ -19,6 +19,8 @@ package org.openecomp.sdc.be.tosca; import org.junit.Before; import org.junit.Test; +import org.mockito.InjectMocks; +import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.MockitoAnnotations; import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; @@ -35,6 +37,7 @@ import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.stream.Collectors; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade; import static java.util.Arrays.asList; import static org.assertj.core.api.Assertions.assertThat; @@ -42,6 +45,14 @@ import static org.mockito.Mockito.doReturn; public class CapabilityRequirementConverterTest { + @InjectMocks + CapabilityRequirementConverter testSubject; + + @Mock + ToscaOperationFacade toscaOperationFacade; + @Mock + private PropertyConvertor propertyConvertorMock; + CapabilityRequirementConverter capabiltyRequirementConvertor = Mockito.spy(new CapabilityRequirementConverter()); ComponentInstance instanceProxy = Mockito.spy( new ComponentInstance() ); ComponentInstance vfInstance = Mockito.spy( new ComponentInstance() ); diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/GroupExportParserImplTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/GroupExportParserImplTest.java index 35be3821b2..b55f7d8514 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/GroupExportParserImplTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/GroupExportParserImplTest.java @@ -68,9 +68,10 @@ public class GroupExportParserImplTest { @Mock private ApplicationDataTypeCache dataTypeCache; - @Mock private Component component; + @Mock + private PropertyConvertor propertyConvertor; @Before public void setUp() throws Exception { @@ -79,13 +80,14 @@ public class GroupExportParserImplTest { private void initGroupExportParser() { when(dataTypeCache.getAll()).thenReturn(Either.left(null)); - groupExportParser = new GroupExportParserImpl(dataTypeCache); + groupExportParser = new GroupExportParserImpl(dataTypeCache, propertyConvertor); } @Test public void failToGetAllDataTypes() { when(dataTypeCache.getAll()).thenReturn(Either.right(null)); - assertThatExceptionOfType(SdcResourceNotFoundException.class).isThrownBy(() -> groupExportParser = new GroupExportParserImpl(dataTypeCache)); + assertThatExceptionOfType(SdcResourceNotFoundException.class).isThrownBy(() -> groupExportParser = new GroupExportParserImpl(dataTypeCache, + propertyConvertor)); } @Test diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/InputAnnotationConvertToToscaTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/InputAnnotationConvertToToscaTest.java index a3d4ae91ab..2d95fc130d 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/InputAnnotationConvertToToscaTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/InputAnnotationConvertToToscaTest.java @@ -77,10 +77,10 @@ public class InputAnnotationConvertToToscaTest { property3.setType(ToscaPropertyType.BOOLEAN.getType()); property3.setValue("True"); - dataTypes = new HashMap(); + dataTypes = new HashMap<>(); DataTypeDefinition dataTypeDefinition = new DataTypeDefinition(); - List properties = new ArrayList(); + List properties = new ArrayList<>(); properties.add(property1); dataTypeDefinition.setProperties(properties); @@ -91,7 +91,7 @@ public class InputAnnotationConvertToToscaTest { annotation.setName("Annotation1"); annotation.setDescription("description1"); - List propertiesAnnotation = new ArrayList(); + List propertiesAnnotation = new ArrayList<>(); propertiesAnnotation.add(property2); propertiesAnnotation.add(property3); annotation.setProperties(propertiesAnnotation); @@ -107,7 +107,7 @@ public class InputAnnotationConvertToToscaTest { ArrayList inputDefList = new ArrayList<> (); inputDefList.add(inputDefinition); - inputConverter = new InputConverter(); + inputConverter = new InputConverter(new PropertyConvertor()); Map resultInputs ; resultInputs = inputConverter.convertInputs(inputDefList,dataTypes); //verify one Input only diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/PolicyExportParserImplTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/PolicyExportParserImplTest.java index 4e377578a3..b499830138 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/PolicyExportParserImplTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/PolicyExportParserImplTest.java @@ -63,6 +63,8 @@ public class PolicyExportParserImplTest { @Mock private ApplicationDataTypeCache dataTypeCache; + @Mock + private PropertyConvertor propertyConvertor; @Mock private Component component; @@ -71,7 +73,8 @@ public class PolicyExportParserImplTest { public void failToGetAllDataTypes() { when(dataTypeCache.getAll()).thenReturn(Either.right(null)); - assertThatExceptionOfType(SdcResourceNotFoundException.class).isThrownBy(() -> policiyExportParser = new PolicyExportParserImpl(dataTypeCache)); + assertThatExceptionOfType(SdcResourceNotFoundException.class).isThrownBy(() -> policiyExportParser = new PolicyExportParserImpl(dataTypeCache, + propertyConvertor)); } @Test @@ -79,7 +82,7 @@ public class PolicyExportParserImplTest { when(dataTypeCache.getAll()).thenReturn(Either.left(null)); when(component.getPolicies()).thenReturn(null); - policiyExportParser = new PolicyExportParserImpl(dataTypeCache); + policiyExportParser = new PolicyExportParserImpl(dataTypeCache, propertyConvertor); Map policies = policiyExportParser.getPolicies(component); assertThat(policies).isEqualTo(null); } @@ -105,7 +108,7 @@ public class PolicyExportParserImplTest { when(component.getPolicies()).thenReturn(policiesToAdd); when(component.getComponentInstances()).thenReturn(getComponentInstances()); when(component.getGroups()).thenReturn(getGroups()); - policiyExportParser = new PolicyExportParserImpl(dataTypeCache); + policiyExportParser = new PolicyExportParserImpl(dataTypeCache, propertyConvertor); Map policies = policiyExportParser.getPolicies(component); diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/PropertyConvertorTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/PropertyConvertorTest.java index 0e6e171a43..d7c53d5bec 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/PropertyConvertorTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/PropertyConvertorTest.java @@ -20,9 +20,25 @@ package org.openecomp.sdc.be.tosca; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; + import fj.data.Either; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; 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.components.utils.PropertyDataDefinitionBuilder; import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition; import org.openecomp.sdc.be.model.DataTypeDefinition; @@ -32,29 +48,20 @@ import org.openecomp.sdc.be.model.tosca.ToscaPropertyType; import org.openecomp.sdc.be.tosca.model.ToscaNodeType; import org.openecomp.sdc.be.tosca.model.ToscaProperty; -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashMap; -import java.util.Iterator; -import java.util.List; -import java.util.Map; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; - +@RunWith(MockitoJUnitRunner.class) public class PropertyConvertorTest { private PropertyDefinition property; - Map dataTypes; + private Map dataTypes; + + @InjectMocks + private PropertyConvertor propertyConvertor; @Before public void setUp(){ property = new PropertyDefinition(); property.setName("myProperty"); property.setType(ToscaPropertyType.INTEGER.getType()); - dataTypes = new HashMap(); + dataTypes = new HashMap<>(); dataTypes.put(property.getName(), new DataTypeDefinition()); } @@ -65,12 +72,12 @@ public class PropertyConvertorTest { property.setSchema(schema); - PropertyConvertor.getInstance().convertProperty(dataTypes, property, PropertyConvertor.PropertyType.PROPERTY); + propertyConvertor.convertProperty(dataTypes, property, PropertyConvertor.PropertyType.PROPERTY); } @Test public void convertPropertyWhenValueAndDefaultNull() { - ToscaProperty prop = PropertyConvertor.getInstance().convertProperty(dataTypes, property, PropertyConvertor.PropertyType.PROPERTY); + ToscaProperty prop = propertyConvertor.convertProperty(dataTypes, property, PropertyConvertor.PropertyType.PROPERTY); assertNotNull(prop); assertNull(prop.getDefaultp()); } @@ -79,7 +86,7 @@ public class PropertyConvertorTest { public void convertPropertyWhenValueNullAndDefaultNotEmpty() { final String def = "1"; property.setDefaultValue(def); - ToscaProperty result = PropertyConvertor.getInstance().convertProperty(dataTypes, property, PropertyConvertor.PropertyType.PROPERTY); + ToscaProperty result = propertyConvertor.convertProperty(dataTypes, property, PropertyConvertor.PropertyType.PROPERTY); assertNotNull(result); assertEquals(Integer.valueOf(def), result.getDefaultp()); } @@ -92,16 +99,15 @@ public class PropertyConvertorTest { property1.setDefaultValue("2"); dataTypes.put(property1.getName(), new DataTypeDefinition()); Resource resource = new Resource(); - List properties = new ArrayList(); + List properties = new ArrayList<>(); properties.add(property); properties.add(property1); resource.setProperties(properties); - Either result = PropertyConvertor.getInstance().convertProperties(resource, new ToscaNodeType(), dataTypes); + Either result = propertyConvertor.convertProperties(resource, new ToscaNodeType(), dataTypes); assertTrue(result.isLeft()); assertEquals(2, result.left().value().getProperties().size()); int cnt = 0; - for (Iterator it = result.left().value().getProperties().values().iterator(); it.hasNext(); ) { - ToscaProperty prop = it.next(); + for (ToscaProperty prop : result.left().value().getProperties().values()) { if (prop.getDefaultp() == null) { cnt++; } @@ -118,15 +124,14 @@ public class PropertyConvertorTest { property.setDefaultValue("1"); dataTypes.put(property1.getName(), new DataTypeDefinition()); Resource resource = new Resource(); - List properties = new ArrayList(); + List properties = new ArrayList<>(); properties.add(property); properties.add(property1); resource.setProperties(properties); - Either result = PropertyConvertor.getInstance().convertProperties(resource, new ToscaNodeType(), dataTypes); + Either result = propertyConvertor.convertProperties(resource, new ToscaNodeType(), dataTypes); assertTrue(result.isLeft()); assertEquals(2, result.left().value().getProperties().size()); - for (Iterator it = result.left().value().getProperties().values().iterator(); it.hasNext(); ) { - ToscaProperty prop = it.next(); + for (ToscaProperty prop : result.left().value().getProperties().values()) { assertNotNull(prop.getDefaultp()); } } @@ -138,15 +143,14 @@ public class PropertyConvertorTest { property1.setType(ToscaPropertyType.INTEGER.getType()); dataTypes.put(property1.getName(), new DataTypeDefinition()); Resource resource = new Resource(); - List properties = new ArrayList(); + List properties = new ArrayList<>(); properties.add(property); properties.add(property1); resource.setProperties(properties); - Either result = PropertyConvertor.getInstance().convertProperties(resource, new ToscaNodeType(), dataTypes); + Either result = propertyConvertor.convertProperties(resource, new ToscaNodeType(), dataTypes); assertTrue(result.isLeft()); assertEquals(2, result.left().value().getProperties().size()); - for (Iterator it = result.left().value().getProperties().values().iterator(); it.hasNext(); ) { - ToscaProperty prop = it.next(); + for (ToscaProperty prop : result.left().value().getProperties().values()) { assertNull(prop.getDefaultp()); } } @@ -157,7 +161,7 @@ public class PropertyConvertorTest { .setDefaultValue("::") .setType(ToscaPropertyType.STRING.getType()) .build(); - ToscaProperty toscaProperty = PropertyConvertor.getInstance().convertProperty(Collections.emptyMap(), property1, PropertyConvertor.PropertyType.PROPERTY); + ToscaProperty toscaProperty = propertyConvertor.convertProperty(Collections.emptyMap(), property1, PropertyConvertor.PropertyType.PROPERTY); assertThat(toscaProperty.getDefaultp()).isEqualTo("::"); } @@ -167,7 +171,7 @@ public class PropertyConvertorTest { .setDefaultValue("/") .setType(ToscaPropertyType.STRING.getType()) .build(); - ToscaProperty toscaProperty = PropertyConvertor.getInstance().convertProperty(Collections.emptyMap(), property1, PropertyConvertor.PropertyType.PROPERTY); + ToscaProperty toscaProperty = propertyConvertor.convertProperty(Collections.emptyMap(), property1, PropertyConvertor.PropertyType.PROPERTY); assertThat(toscaProperty.getDefaultp()).isEqualTo("/"); } diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java index ca4f569cf3..45cdbbdfaa 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java @@ -23,10 +23,14 @@ package org.openecomp.sdc.be.tosca; import static org.hamcrest.CoreMatchers.is; import static org.junit.Assert.assertThat; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyBoolean; import static org.mockito.ArgumentMatchers.anyList; import static org.mockito.ArgumentMatchers.anyMap; import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.ArgumentMatchers.isNull; +import static org.mockito.Mockito.doReturn; +import static org.openecomp.sdc.be.tosca.PropertyConvertor.PropertyType.PROPERTY; import fj.data.Either; import java.util.ArrayList; @@ -35,6 +39,7 @@ import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.Optional; import java.util.stream.Collectors; import mockit.Deencapsulation; import org.apache.commons.collections.MapUtils; @@ -50,9 +55,11 @@ import org.mockito.MockitoAnnotations; import org.openecomp.sdc.be.components.BeConfDependentTest; import org.openecomp.sdc.be.components.utils.PropertyDataDefinitionBuilder; import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition; import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition; import org.openecomp.sdc.be.datatypes.elements.ForwardingPathElementDataDefinition; import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition; import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition; import org.openecomp.sdc.be.datatypes.elements.ToscaArtifactDataDefinition; @@ -103,6 +110,7 @@ public class ToscaExportHandlerTest extends BeConfDependentTest { private static final String COMPONENT_INPUT_TYPE = "integer"; private static final String RESOURCE_NAME = "resource"; private static final String TOSCA_VERSION = "tosca_simple_yaml_1_1"; + private static final Map DATA_TYPES = new HashMap<>(); @InjectMocks private ToscaExportHandler testSubject; @@ -122,18 +130,27 @@ public class ToscaExportHandlerTest extends BeConfDependentTest { @Mock private GroupExportParser groupExportParser; + @Mock + private PropertyConvertor propertyConvertor; + @Mock private GroupExportParserImpl groupExportParserImpl; @Mock private InterfaceLifecycleOperation interfaceLifecycleOperation; + @Mock + private InterfacesOperationsConverter interfacesOperationsConverter; + @Mock private PolicyExportParser policyExportParser; @Before public void setUpMock() throws Exception { MockitoAnnotations.initMocks(this); + doReturn(new ToscaProperty()).when(propertyConvertor).convertProperty(any(), any(), eq(PROPERTY)); + doReturn(new HashMap()).when(interfacesOperationsConverter) + .getInterfacesMap(any(), isNull(), anyMap(), anyMap(), anyBoolean(), anyBoolean()); } private Resource getNewResource() { @@ -1427,4 +1444,151 @@ public class ToscaExportHandlerTest extends BeConfDependentTest { Assert.assertTrue(result.get("test_art").getFile().equals("test_file")); Assert.assertTrue(result.get("test_art").getType().equals("test_type")); } + + @Test + public void testGetProxyNodeTypeInterfacesNoInterfaces() { + Component service = new Service(); + Optional> proxyNodeTypeInterfaces = + testSubject.getProxyNodeTypeInterfaces(service, DATA_TYPES); + Assert.assertFalse(proxyNodeTypeInterfaces.isPresent()); + } + + @Test + public void testGetProxyNodeTypeInterfaces() { + Component service = getTestComponent(); + Optional> proxyNodeTypeInterfaces = + testSubject.getProxyNodeTypeInterfaces(service, DATA_TYPES); + Assert.assertTrue(proxyNodeTypeInterfaces.isPresent()); + Map componentInterfaces = proxyNodeTypeInterfaces.get(); + Assert.assertNotNull(componentInterfaces); + } + + + @Test + public void testGetProxyNodeTypePropertiesComponentNull() { + Optional> proxyNodeTypeProperties = + testSubject.getProxyNodeTypeProperties(null, DATA_TYPES); + Assert.assertFalse(proxyNodeTypeProperties.isPresent()); + } + + @Test + public void testGetProxyNodeTypePropertiesNoProperties() { + Component service = new Service(); + Optional> proxyNodeTypeProperties = + testSubject.getProxyNodeTypeProperties(service, DATA_TYPES); + Assert.assertFalse(proxyNodeTypeProperties.isPresent()); + } + + @Test + public void testGetProxyNodeTypeProperties() { + Component service = getTestComponent(); + service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"), + createMockProperty("componentPropInt", null))); + Optional> proxyNodeTypeProperties = + testSubject.getProxyNodeTypeProperties(service, DATA_TYPES); + Assert.assertTrue(proxyNodeTypeProperties.isPresent()); + Map componentProperties = proxyNodeTypeProperties.get(); + Assert.assertNotNull(componentProperties); + Assert.assertEquals(2, componentProperties.size()); + } + + @Test + public void testAddInputsToPropertiesNoInputs() { + Component service = getTestComponent(); + service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"), + createMockProperty("componentPropInt", null))); + Optional> proxyNodeTypePropertiesResult = + testSubject.getProxyNodeTypeProperties(service, DATA_TYPES); + + Assert.assertTrue(proxyNodeTypePropertiesResult.isPresent()); + Map proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get(); + testSubject.addInputsToProperties(DATA_TYPES, null, proxyNodeTypeProperties); + Assert.assertNotNull(proxyNodeTypeProperties); + Assert.assertEquals(2, proxyNodeTypeProperties.size()); + testSubject.addInputsToProperties(DATA_TYPES, new ArrayList<>(), proxyNodeTypeProperties); + Assert.assertEquals(2, proxyNodeTypeProperties.size()); + } + + @Test + public void testAddInputsToPropertiesWithInputs() { + Component service = getTestComponent(); + service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"), + createMockProperty("componentPropInt", null))); + service.setInputs(Arrays.asList(createMockInput("componentInputStr1", + "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2"))); + Optional> proxyNodeTypePropertiesResult = + testSubject.getProxyNodeTypeProperties(service, DATA_TYPES); + + Assert.assertTrue(proxyNodeTypePropertiesResult.isPresent()); + Map proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get(); + testSubject.addInputsToProperties(DATA_TYPES, service.getInputs(), proxyNodeTypeProperties); + Assert.assertNotNull(proxyNodeTypeProperties); + Assert.assertEquals(4, proxyNodeTypeProperties.size()); + } + + @Test + public void testAddInputsToPropertiesOnlyInputs() { + Component service = getTestComponent(); + service.setInputs(Arrays.asList(createMockInput("componentInputStr1", + "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2"))); + Optional> proxyNodeTypePropertiesResult = + testSubject.getProxyNodeTypeProperties(service, DATA_TYPES); + + Assert.assertTrue(proxyNodeTypePropertiesResult.isPresent()); + Map proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get(); + testSubject.addInputsToProperties(DATA_TYPES, service.getInputs(), proxyNodeTypeProperties); + Assert.assertNotNull(proxyNodeTypeProperties); + Assert.assertEquals(2, proxyNodeTypeProperties.size()); + } + + @Test + public void testOperationImplementationInProxyNodeTypeNotPresent() { + Component service = getTestComponent(); + InterfaceDefinition interfaceDefinition = + service.getInterfaces().get("normalizedServiceComponentName-interface"); + interfaceDefinition.setOperations(new HashMap<>()); + final OperationDataDefinition operation = new OperationDataDefinition(); + operation.setName("start"); + operation.setDescription("op description"); + final ArtifactDataDefinition implementation = new ArtifactDataDefinition(); + implementation.setArtifactName("createBPMN.bpmn"); + operation.setImplementation(implementation); + interfaceDefinition.getOperations().put(operation.getName(), operation); + service.getInterfaces().put("normalizedServiceComponentName-interface", interfaceDefinition); + service.setInputs(Arrays.asList(createMockInput("componentInputStr1", + "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2"))); + Optional> proxyNodeTypeInterfaces = + testSubject.getProxyNodeTypeInterfaces(service, DATA_TYPES); + Assert.assertTrue(proxyNodeTypeInterfaces.isPresent()); + Map componentInterfaces = proxyNodeTypeInterfaces.get(); + Assert.assertNotNull(componentInterfaces); + } + + private Component getTestComponent() { + Component component = new Service(); + component.setNormalizedName("normalizedServiceComponentName"); + InterfaceDefinition addedInterface = new InterfaceDefinition(); + addedInterface.setType("com.some.service.or.other.serviceName"); + final String interfaceType = "normalizedServiceComponentName-interface"; + component.setInterfaces(new HashMap<>()); + component.getInterfaces().put(interfaceType, addedInterface); + return component; + } + + private PropertyDefinition createMockProperty(String propertyName, String defaultValue){ + PropertyDefinition propertyDefinition = new PropertyDefinition(); + propertyDefinition.setName(propertyName); + propertyDefinition.setType("string"); + propertyDefinition.setDefaultValue(defaultValue); + return propertyDefinition; + } + + private InputDefinition createMockInput(String inputName, String defaultValue){ + InputDefinition inputDefinition = new InputDefinition(); + inputDefinition.setName(inputName); + inputDefinition.setType("string"); + inputDefinition.setDefaultValue(defaultValue); + return inputDefinition; + } + } diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportUtilsTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportUtilsTest.java deleted file mode 100644 index 55a2083e7c..0000000000 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportUtilsTest.java +++ /dev/null @@ -1,198 +0,0 @@ -/* - * Copyright © 2016-2019 European Support Limited - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.openecomp.sdc.be.tosca; - -import org.junit.Assert; -import org.junit.Test; -import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition; -import org.openecomp.sdc.be.model.Component; -import org.openecomp.sdc.be.model.DataTypeDefinition; -import org.openecomp.sdc.be.model.InputDefinition; -import org.openecomp.sdc.be.model.InterfaceDefinition; -import org.openecomp.sdc.be.model.PropertyDefinition; -import org.openecomp.sdc.be.model.Service; -import org.openecomp.sdc.be.tosca.model.ToscaProperty; -import org.openecomp.sdc.be.tosca.utils.ToscaExportUtils; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.HashMap; -import java.util.Map; -import java.util.Optional; - -public class ToscaExportUtilsTest { - - private static final Map dataTypes = new HashMap<>(); - - @Test - public void testGetProxyNodeTypeInterfacesNoInterfaces() { - Component service = new Service(); - Optional> proxyNodeTypeInterfaces = - ToscaExportUtils.getProxyNodeTypeInterfaces(service, dataTypes); - Assert.assertFalse(proxyNodeTypeInterfaces.isPresent()); - } - - @Test - public void testGetProxyNodeTypeInterfaces() { - Component service = getTestComponent(); - Optional> proxyNodeTypeInterfaces = - ToscaExportUtils.getProxyNodeTypeInterfaces(service, dataTypes); - Assert.assertTrue(proxyNodeTypeInterfaces.isPresent()); - Map componentInterfaces = proxyNodeTypeInterfaces.get(); - Assert.assertNotNull(componentInterfaces); - Assert.assertEquals(1, componentInterfaces.size()); - } - - - @Test - public void testGetProxyNodeTypePropertiesComponentNull() { - Optional> proxyNodeTypeProperties = - ToscaExportUtils.getProxyNodeTypeProperties(null, dataTypes); - Assert.assertFalse(proxyNodeTypeProperties.isPresent()); - } - - @Test - public void testGetProxyNodeTypePropertiesNoProperties() { - Component service = new Service(); - Optional> proxyNodeTypeProperties = - ToscaExportUtils.getProxyNodeTypeProperties(service, dataTypes); - Assert.assertFalse(proxyNodeTypeProperties.isPresent()); - } - - @Test - public void testGetProxyNodeTypeProperties() { - Component service = getTestComponent(); - service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"), - createMockProperty("componentPropInt", null))); - Optional> proxyNodeTypeProperties = - ToscaExportUtils.getProxyNodeTypeProperties(service, dataTypes); - Assert.assertTrue(proxyNodeTypeProperties.isPresent()); - Map componentProperties = proxyNodeTypeProperties.get(); - Assert.assertNotNull(componentProperties); - Assert.assertEquals(2, componentProperties.size()); - } - - @Test - public void testAddInputsToPropertiesNoInputs() { - Component service = getTestComponent(); - service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"), - createMockProperty("componentPropInt", null))); - Optional> proxyNodeTypePropertiesResult = - ToscaExportUtils.getProxyNodeTypeProperties(service, dataTypes); - - Assert.assertTrue(proxyNodeTypePropertiesResult.isPresent()); - Map proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get(); - ToscaExportUtils.addInputsToProperties(dataTypes, null, proxyNodeTypeProperties); - Assert.assertNotNull(proxyNodeTypeProperties); - Assert.assertEquals(2, proxyNodeTypeProperties.size()); - ToscaExportUtils.addInputsToProperties(dataTypes, new ArrayList<>(), proxyNodeTypeProperties); - Assert.assertEquals(2, proxyNodeTypeProperties.size()); - } - - @Test - public void testAddInputsToPropertiesWithInputs() { - Component service = getTestComponent(); - service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"), - createMockProperty("componentPropInt", null))); - service.setInputs(Arrays.asList(createMockInput("componentInputStr1", - "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2"))); - Optional> proxyNodeTypePropertiesResult = - ToscaExportUtils.getProxyNodeTypeProperties(service, dataTypes); - - Assert.assertTrue(proxyNodeTypePropertiesResult.isPresent()); - Map proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get(); - ToscaExportUtils.addInputsToProperties(dataTypes, service.getInputs(), proxyNodeTypeProperties); - Assert.assertNotNull(proxyNodeTypeProperties); - Assert.assertEquals(4, proxyNodeTypeProperties.size()); - Assert.assertNotNull(proxyNodeTypeProperties.get("componentInputStr1")); - Assert.assertNotNull(proxyNodeTypeProperties.get("componentInputStr2")); - } - - @Test - public void testAddInputsToPropertiesOnlyInputs() { - Component service = getTestComponent(); - service.setInputs(Arrays.asList(createMockInput("componentInputStr1", - "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2"))); - Optional> proxyNodeTypePropertiesResult = - ToscaExportUtils.getProxyNodeTypeProperties(service, dataTypes); - - Assert.assertTrue(proxyNodeTypePropertiesResult.isPresent()); - Map proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get(); - ToscaExportUtils.addInputsToProperties(dataTypes, service.getInputs(), proxyNodeTypeProperties); - Assert.assertNotNull(proxyNodeTypeProperties); - Assert.assertEquals(2, proxyNodeTypeProperties.size()); - Assert.assertNotNull(proxyNodeTypeProperties.get("componentInputStr1")); - Assert.assertNotNull(proxyNodeTypeProperties.get("componentInputStr2")); - } - - @Test - public void testOperationImplementationInProxyNodeTypeNotPresent() { - Component service = getTestComponent(); - InterfaceDefinition interfaceDefinition = - service.getInterfaces().get("normalizedServiceComponentName-interface"); - interfaceDefinition.setOperations(new HashMap<>()); - final OperationDataDefinition operation = new OperationDataDefinition(); - operation.setName("start"); - operation.setDescription("op description"); - final ArtifactDataDefinition implementation = new ArtifactDataDefinition(); - implementation.setArtifactName("createBPMN.bpmn"); - operation.setImplementation(implementation); - interfaceDefinition.getOperations().put(operation.getName(), operation); - service.getInterfaces().put("normalizedServiceComponentName-interface", interfaceDefinition); - service.setInputs(Arrays.asList(createMockInput("componentInputStr1", - "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2"))); - Optional> proxyNodeTypeInterfaces = - ToscaExportUtils.getProxyNodeTypeInterfaces(service, dataTypes); - Assert.assertTrue(proxyNodeTypeInterfaces.isPresent()); - Map componentInterfaces = proxyNodeTypeInterfaces.get(); - Assert.assertNotNull(componentInterfaces); - Assert.assertEquals(1, componentInterfaces.size()); - Map proxyInterfaceDefinition = - (Map) componentInterfaces.get("serviceName"); - Map startOperationDefinition = (Map) proxyInterfaceDefinition.get("start"); - Assert.assertNotNull(startOperationDefinition); - Assert.assertNull(startOperationDefinition.get("implementation")); - } - - private Component getTestComponent() { - Component component = new Service(); - component.setNormalizedName("normalizedServiceComponentName"); - InterfaceDefinition addedInterface = new InterfaceDefinition(); - addedInterface.setType("com.some.service.or.other.serviceName"); - final String interfaceType = "normalizedServiceComponentName-interface"; - component.setInterfaces(new HashMap<>()); - component.getInterfaces().put(interfaceType, addedInterface); - return component; - } - - private PropertyDefinition createMockProperty(String propertyName, String defaultValue){ - PropertyDefinition propertyDefinition = new PropertyDefinition(); - propertyDefinition.setName(propertyName); - propertyDefinition.setType("string"); - propertyDefinition.setDefaultValue(defaultValue); - return propertyDefinition; - } - - private InputDefinition createMockInput(String inputName, String defaultValue){ - InputDefinition inputDefinition = new InputDefinition(); - inputDefinition.setName(inputName); - inputDefinition.setType("string"); - inputDefinition.setDefaultValue(defaultValue); - return inputDefinition; - } -} diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsConverterTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsConverterTest.java new file mode 100644 index 0000000000..13bc009d32 --- /dev/null +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsConverterTest.java @@ -0,0 +1,552 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openecomp.sdc.be.tosca.utils; + +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.google.gson.Gson; +import org.apache.commons.collections4.MapUtils; +import org.junit.Assert; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.junit.MockitoJUnitRunner; +import org.onap.sdc.tosca.services.YamlUtil; +import org.openecomp.sdc.be.DummyConfigurationManager; +import org.openecomp.sdc.be.config.Configuration; +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.DataTypeDefinition; +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.model.ServiceMetadataDefinition; +import org.openecomp.sdc.be.model.tosca.ToscaFunctions; +import org.openecomp.sdc.be.tosca.InterfacesOperationsConverter; +import org.openecomp.sdc.be.tosca.PropertyConvertor; +import org.openecomp.sdc.be.tosca.ToscaExportHandler; +import org.openecomp.sdc.be.tosca.ToscaRepresentation; +import org.openecomp.sdc.be.tosca.model.ToscaNodeType; +import org.openecomp.sdc.be.tosca.model.ToscaTemplate; +import org.openecomp.sdc.common.util.YamlToObjectConverter; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; + +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; +import static org.openecomp.sdc.be.tosca.InterfacesOperationsConverter.SELF; +import static org.openecomp.sdc.be.tosca.InterfacesOperationsConverter.addInterfaceTypeElement; +@RunWith(MockitoJUnitRunner.class) +public class InterfacesOperationsConverterTest { + + 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; + private Configuration.EnvironmentContext environmentContext = mock(Configuration.EnvironmentContext.class); + DummyConfigurationManager dummyConfigurationManager = new DummyConfigurationManager(); + private static final Map dataTypes = new HashMap<>(); + + private InterfacesOperationsConverter interfacesOperationsConverter; + + @BeforeClass + public static void setUp() { + mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + } + + @Before + public void setUpBeforeTest() { + interfacesOperationsConverter = + new InterfacesOperationsConverter(new PropertyConvertor()); + } + + @Test + public void addInterfaceTypeElementToResource() { + Component component = new Resource(); + component.setNormalizedName("normalizedComponentName"); + component.setMetadataDefinition(new ServiceMetadataDefinition()); + component.getComponentMetadataDefinition().getMetadataDataDefinition().setName("NodeTypeName"); + component.getComponentMetadataDefinition().getMetadataDataDefinition().setSystemName("NodeTypeName"); + InterfaceDefinition addedInterface = new InterfaceDefinition(); + addedInterface.setType("Local"); + addOperationsToInterface(component, addedInterface, 5, 3, true, false); + final String interfaceType = "normalizedComponentName-interface"; + component.setInterfaces(new HashMap<>()); + component.getInterfaces().put(interfaceType, addedInterface); + final Map interfaceTypeElement = + addInterfaceTypeElement(component, new ArrayList<>()); + + ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null, null, + interfacesOperationsConverter); + ToscaTemplate template = new ToscaTemplate("test"); + template.setInterface_types(interfaceTypeElement); + final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template); + + Assert.assertFalse(toscaRepresentation.getMainYaml().contains("operations")); + Assert.assertTrue(toscaRepresentation.getMainYaml().contains("NodeTypeName")); + } + + @Test + public void addInterfaceTypeElementToService() { + Component component = new Service(); + component.setNormalizedName("normalizedServiceComponentName"); + component.setMetadataDefinition(new ServiceMetadataDefinition()); + component.getComponentMetadataDefinition().getMetadataDataDefinition().setName("NodeTypeName"); + component.getComponentMetadataDefinition().getMetadataDataDefinition().setSystemName("NodeTypeName"); + InterfaceDefinition addedInterface = new InterfaceDefinition(); + addedInterface.setType("Local"); + addOperationsToInterface(component, addedInterface, 5, 3, true, false); + final String interfaceType = "normalizedServiceComponentName-interface"; + component.setInterfaces(new HashMap<>()); + component.getInterfaces().put(interfaceType, addedInterface); + final Map interfaceTypeElement = + addInterfaceTypeElement(component, new ArrayList<>()); + + ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null, null, + interfacesOperationsConverter); + ToscaTemplate template = new ToscaTemplate("testService"); + template.setInterface_types(interfaceTypeElement); + final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template); + + Assert.assertFalse(toscaRepresentation.getMainYaml().contains("operations")); + Assert.assertTrue(toscaRepresentation.getMainYaml().contains("NodeTypeName")); + } + + @Test + public void addInterfaceDefinitionElementToResource() { + Component component = new Resource(); + component.setNormalizedName("normalizedComponentName"); + InterfaceDefinition addedInterface = new InterfaceDefinition(); + addedInterface.setType("com.some.resource.or.other.resourceName"); + + 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(); + interfacesOperationsConverter.addInterfaceDefinitionElement(component, nodeType, dataTypes, false); + + ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null, null, + interfacesOperationsConverter); + ToscaTemplate template = new ToscaTemplate(NODE_TYPE_NAME); + Map nodeTypes = new HashMap<>(); + nodeTypes.put(NODE_TYPE_NAME, nodeType); + template.setNode_types(nodeTypes); + final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template); + + String mainYaml = toscaRepresentation.getMainYaml(); + Assert.assertFalse(mainYaml.contains("operations")); + Assert.assertTrue(mainYaml.contains("resourceName:")); + Assert.assertTrue(mainYaml.contains("inputs:")); + validateOperationInputs(mainYaml, 2, null); + Assert.assertFalse(mainYaml.contains("defaultp")); + Assert.assertTrue(mainYaml.contains("has description")); + Assert.assertTrue(mainYaml.contains(MAPPED_PROPERTY_NAME)); + Assert.assertTrue(mainYaml.contains("com.some.resource.or.other.resourceName")); + } + + @Test + public void addInterfaceDefinitionElementToService() { + Component component = new Service(); + component.setNormalizedName("normalizedServiceComponentName"); + InterfaceDefinition addedInterface = new InterfaceDefinition(); + addedInterface.setType("com.some.service.or.other.serviceName"); + 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(); + interfacesOperationsConverter.addInterfaceDefinitionElement(component, nodeType, dataTypes, false); + + ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null, null, + interfacesOperationsConverter); + ToscaTemplate template = new ToscaTemplate("testService"); + Map nodeTypes = new HashMap<>(); + nodeTypes.put(NODE_TYPE_NAME, nodeType); + template.setNode_types(nodeTypes); + final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template); + String mainYaml = toscaRepresentation.getMainYaml(); + Assert.assertFalse(mainYaml.contains("operations")); + Assert.assertTrue(mainYaml.contains("serviceName:")); + Assert.assertTrue(mainYaml.contains("inputs:")); + validateOperationInputs(mainYaml, 2, null); + Assert.assertFalse(mainYaml.contains("defaultp")); + Assert.assertTrue(mainYaml.contains("has description")); + Assert.assertTrue(mainYaml.contains(MAPPED_PROPERTY_NAME)); + Assert.assertTrue(mainYaml.contains("com.some.service.or.other.serviceName")); + } + + + @Test + public void testGetInterfaceAsMapServiceProxy() { + Component component = new Resource(); + component.setNormalizedName("normalizedComponentName"); + InterfaceDefinition addedInterface = new InterfaceDefinition(); + addedInterface.setToscaResourceName("com.some.resource.or.other.resourceName"); + addedInterface.setType("com.some.resource.or.other.resourceName"); + addOperationsToInterface(component, addedInterface, 3, 2, true, false); + final String interfaceType = "normalizedComponentName-interface"; + component.setInterfaces(new HashMap<>()); + component.getInterfaces().put(interfaceType, addedInterface); + Map interfacesMap = interfacesOperationsConverter + .getInterfacesMap(component, null, component.getInterfaces(), null, false, true); + ToscaNodeType nodeType = new ToscaNodeType(); + nodeType.setInterfaces(interfacesMap); + ToscaExportHandler handler = new ToscaExportHandler(); + ToscaTemplate template = new ToscaTemplate(NODE_TYPE_NAME); + Map nodeTypes = new HashMap<>(); + nodeTypes.put(NODE_TYPE_NAME, nodeType); + template.setNode_types(nodeTypes); + final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template); + + String mainYaml = toscaRepresentation.getMainYaml(); + Assert.assertFalse(mainYaml.contains("operations")); + Assert.assertTrue(mainYaml.contains("resourceName:")); + Assert.assertTrue(mainYaml.contains("inputs:")); + validateServiceProxyOperationInputs(mainYaml); + Assert.assertFalse(mainYaml.contains("defaultp")); + Assert.assertTrue(mainYaml.contains("has description")); + Assert.assertTrue(mainYaml.contains(MAPPED_PROPERTY_NAME)); + Assert.assertTrue(mainYaml.contains("com.some.resource.or.other.resourceName")); + } + + @Test + public void addInterfaceDefinitionElement_noInputs() { + Component component = new Resource(); + component.setNormalizedName("normalizedComponentName"); + InterfaceDefinition addedInterface = new InterfaceDefinition(); + addedInterface.setType("com.some.resource.or.other.resourceNameNoInputs"); + 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(); + interfacesOperationsConverter.addInterfaceDefinitionElement(component, nodeType, null, false); + + ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null, null, + interfacesOperationsConverter); + ToscaTemplate template = new ToscaTemplate("test"); + Map nodeTypes = new HashMap<>(); + nodeTypes.put("test", nodeType); + template.setNode_types(nodeTypes); + final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template); + + Assert.assertFalse(toscaRepresentation.getMainYaml().contains("operations")); + Assert.assertFalse(toscaRepresentation.getMainYaml().contains(INPUT_NAME_PREFIX)); + Assert.assertFalse(toscaRepresentation.getMainYaml().contains("defaultp")); + Assert.assertTrue(toscaRepresentation.getMainYaml().contains("resourceNameNoInputs:")); + Assert.assertTrue(toscaRepresentation.getMainYaml().contains("has description")); + 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(); + interfacesOperationsConverter.addInterfaceDefinitionElement(component, nodeType, dataTypes, false); + + ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null, null, + interfacesOperationsConverter); + ToscaTemplate template = new ToscaTemplate("test"); + Map 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"); + } + + @Test + public void addInterfaceDefinitionElementInputMappedToOtherOperationOutputFromOtherInterface() { + 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(opInputDef -> opInputDef.getName().contains("integer")) + .forEach(opInputDef -> opInputDef.setInputId( + addedInterfaceType +".name_for_op_1.output_integer_1"))); + //Mapping to operation from another interface + String secondInterfaceType = "org.test.lifecycle.standard.interfaceType.second"; + InterfaceDefinition secondInterface = new InterfaceDefinition(); + secondInterface.setType(secondInterfaceType); + addOperationsToInterface(component, secondInterface, 2, 2, true, true); + secondInterface.getOperationsMap().values().stream() + .filter(operationInputDefinition -> operationInputDefinition.getName().equalsIgnoreCase( + "name_for_op_0")) + .forEach(operation -> operation.getInputs().getListToscaDataDefinition().stream() + .filter(opInputDef -> opInputDef.getName().contains("integer")) + .forEach(opInputDef -> opInputDef.setInputId( + addedInterfaceType +".name_for_op_1.output_integer_1"))); + component.setInterfaces(new HashMap<>()); + component.getInterfaces().put(addedInterfaceType, addedInterface); + component.getInterfaces().put(secondInterfaceType, secondInterface); + + ToscaNodeType nodeType = new ToscaNodeType(); + interfacesOperationsConverter.addInterfaceDefinitionElement(component, nodeType, dataTypes, false); + + ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null, null, + interfacesOperationsConverter); + ToscaTemplate template = new ToscaTemplate("test"); + Map 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(Component component, InterfaceDefinition addedInterface, int numOfOps, + int numOfInputsPerOp, boolean hasInputs, boolean hasOutputs) { + + addedInterface.setOperations(new HashMap<>()); + for (int i = 0; i < numOfOps; i++) { + final OperationDataDefinition operation = new OperationDataDefinition(); + operation.setName("name_for_op_" + i); + operation.setDescription("op " + i + " has description"); + final ArtifactDataDefinition implementation = new ArtifactDataDefinition(); + implementation.setArtifactName(i + "_createBPMN.bpmn"); + operation.setImplementation(implementation); + if (hasInputs) { + operation.setInputs(createInputs(component, numOfInputsPerOp)); + } + if (hasOutputs) { + operation.setOutputs(createOutputs(addedInterface.getToscaResourceName(), + operation.getName(), numOfInputsPerOp)); + } + addedInterface.getOperations().put(operation.getName(), operation); + } + } + + private ListDataDefinition createInputs(Component component, int numOfInputs) { + ListDataDefinition 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, 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 createOutputs(String interfaceName, + String operationName, + int numOfOutputs) { + ListDataDefinition operationOutputDefinitionList = new ListDataDefinition<>(); + for (int i = 0; i < numOfOutputs; i++) { + operationOutputDefinitionList.add(createMockOperationOutputDefinition(interfaceName, operationName, + OUTPUT_NAME_PREFIX + inputTypes[i] + "_" + i, i)); + } + return operationOutputDefinitionList; + } + + private OperationInputDefinition createMockOperationInputDefinition(String name, String id, int index) { + OperationInputDefinition operationInputDefinition = new OperationInputDefinition(); + operationInputDefinition.setName(name); + operationInputDefinition.setInputId(id); + operationInputDefinition.setType(inputTypes[index]); + operationInputDefinition.setRequired(index % 2 == 0); + Map> toscaDefaultValueMap = new HashMap<>(); + List toscaDefaultValues = new ArrayList<>(); + toscaDefaultValues.add(SELF); + toscaDefaultValues.add(id.substring(id.lastIndexOf('.') + 1)); + toscaDefaultValueMap.put(ToscaFunctions.GET_PROPERTY.getFunctionName(), toscaDefaultValues); + operationInputDefinition.setToscaDefaultValue(new Gson().toJson(toscaDefaultValueMap)); + operationInputDefinition.setSource("ServiceInput"); + return operationInputDefinition; + } + + private OperationOutputDefinition createMockOperationOutputDefinition(String interfaceName, String operationName, + String outputName, int index) { + OperationOutputDefinition operationInputDefinition = new OperationOutputDefinition(); + operationInputDefinition.setName(outputName); + operationInputDefinition.setType(inputTypes[index]); + operationInputDefinition.setRequired(index % 2 == 0); + Map> toscaDefaultValueMap = new HashMap<>(); + List toscaDefaultValues = new ArrayList<>(); + toscaDefaultValues.add(SELF); + toscaDefaultValues.add(interfaceName); + toscaDefaultValues.add(operationName); + toscaDefaultValues.add(outputName); + toscaDefaultValueMap.put(ToscaFunctions.GET_OPERATION_OUTPUT.getFunctionName(), toscaDefaultValues); + 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() + + String.valueOf(numOfInputsPerOp).length()); + YamlToObjectConverter objectConverter = new YamlToObjectConverter(); + ToscaNodeType toscaNodeType = objectConverter.convert(nodeTypesRepresentation.getBytes(), ToscaNodeType.class); + Map interfaces = toscaNodeType.getInterfaces(); + for (Map.Entry interfaceEntry : interfaces.entrySet()) { + Map interfaceDefinition = mapper.convertValue(interfaceEntry.getValue(), Map.class); + for (Map.Entry operationEntry : interfaceDefinition.entrySet()) { + Object operationVal = operationEntry.getValue(); + if (operationVal instanceof Map) { + //Since the inputs are mapped to output operations from only first interface so using that name + validateOperationInputDefinition(interfaces.keySet().iterator().next(), mappedOperationName, + operationVal); + } + } + } + } + + private void validateOperationInputDefinition(String interfaceType, String operationName, Object operationVal) { + Map operation = mapper.convertValue(operationVal, Map.class); + Map inputs = (Map) operation.get("inputs"); + for (Map.Entry inputEntry : inputs.entrySet()) { + String[] inputNameSplit = inputEntry.getKey().split("_"); + Map inputValueObject = (Map) 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 inputValueObject) { + Map mappedInputValue = (Map) inputValueObject.get("default"); + if(mappedInputValue.containsKey(ToscaFunctions.GET_PROPERTY.getFunctionName())) { + String mappedPropertyValue = MAPPED_PROPERTY_NAME + index; + List mappedPropertyDefaultValue = (List) mappedInputValue.get(ToscaFunctions.GET_PROPERTY.getFunctionName()); + Assert.assertEquals(2, mappedPropertyDefaultValue.size()); + Assert.assertTrue(mappedPropertyDefaultValue.contains(SELF)); + Assert.assertTrue(mappedPropertyDefaultValue.contains(mappedPropertyValue)); + } else if(mappedInputValue.containsKey(ToscaFunctions.GET_OPERATION_OUTPUT.getFunctionName())) { + List mappedPropertyDefaultValue = (List) mappedInputValue.get(ToscaFunctions.GET_OPERATION_OUTPUT.getFunctionName()); + 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: "+ ToscaFunctions.GET_PROPERTY.getFunctionName() + + "/"+ ToscaFunctions.GET_OPERATION_OUTPUT.getFunctionName()); + } + } + + private void validateServiceProxyOperationInputs(String mainYaml) { + String nodeTypeKey = NODE_TYPE_NAME + ":"; + String nodeTypesRepresentation = mainYaml.substring(mainYaml.indexOf(nodeTypeKey) + nodeTypeKey.length(), + mainYaml.lastIndexOf(MAPPED_PROPERTY_NAME) + MAPPED_PROPERTY_NAME.length()); + YamlUtil yamlUtil = new YamlUtil(); + ToscaNodeType toscaNodeType = yamlUtil.yamlToObject(nodeTypesRepresentation, ToscaNodeType.class); + for (Object interfaceVal : toscaNodeType.getInterfaces().values()) { + Map interfaceDefinition = mapper.convertValue(interfaceVal, Map.class); + for (Object operationVal : interfaceDefinition.values()) { + if (operationVal instanceof Map) { + Map operation = (Map) mapper.convertValue(operationVal, Map.class); + Map operationInputs = (Map) operation.get("inputs"); + for (Object inputValue : operationInputs.values()) { + Map inputValueAsMap = (Map) inputValue; + Assert.assertFalse(inputValueAsMap.keySet().contains("type")); + Assert.assertFalse(inputValueAsMap.keySet().contains("required")); + Assert.assertFalse(inputValueAsMap.keySet().contains("default")); + } + } + } + } + } + + @Test + public void testAddInterfaceTypeElementGetCorrectLocalInterfaceName() { + Service service = new Service(); + service.setMetadataDefinition(new ServiceMetadataDefinition()); + service.getComponentMetadataDefinition().getMetadataDataDefinition().setName("LocalInterface"); + service.getComponentMetadataDefinition().getMetadataDataDefinition().setSystemName("LocalInterface"); + service.setInterfaces(Collections.singletonMap("Local", new InterfaceDefinition("Local", null, new HashMap<>()))); + + Map resultMap = InterfacesOperationsConverter.addInterfaceTypeElement(service, + Collections.singletonList("org.openecomp.interfaces.node.lifecycle.Standard")); + + Assert.assertTrue(MapUtils.isNotEmpty(resultMap) + && resultMap.containsKey("org.openecomp.interfaces.node.lifecycle.LocalInterface")); + } + + @Test + public void testAddInterfaceTypeElementNoTypeChangeIfNotLocal() { + Service service = new Service(); + service.setMetadataDefinition(new ServiceMetadataDefinition()); + service.getComponentMetadataDefinition().getMetadataDataDefinition().setName("LocalInterface"); + service.setInterfaces(Collections.singletonMap("NotLocal", new InterfaceDefinition("NotLocal", null, + new HashMap<>()))); + + Map resultMap = interfacesOperationsConverter.getInterfacesMap(service, null, + service.getInterfaces(), null, false, false); + + Assert.assertTrue(MapUtils.isNotEmpty(resultMap) + && resultMap.containsKey("NotLocal")); + } +} 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 deleted file mode 100644 index d6a7b86f16..0000000000 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsToscaUtilTest.java +++ /dev/null @@ -1,543 +0,0 @@ -/* - * Copyright © 2016-2018 European Support Limited - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.openecomp.sdc.be.tosca.utils; - -import com.fasterxml.jackson.databind.DeserializationFeature; -import com.fasterxml.jackson.databind.ObjectMapper; -import com.google.gson.Gson; -import org.apache.commons.collections4.MapUtils; -import org.junit.Assert; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.Test; -import org.onap.sdc.tosca.services.YamlUtil; -import org.openecomp.sdc.be.DummyConfigurationManager; -import org.openecomp.sdc.be.config.Configuration; -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.DataTypeDefinition; -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.model.ServiceMetadataDefinition; -import org.openecomp.sdc.be.model.tosca.ToscaFunctions; -import org.openecomp.sdc.be.tosca.ToscaExportHandler; -import org.openecomp.sdc.be.tosca.ToscaRepresentation; -import org.openecomp.sdc.be.tosca.model.ToscaNodeType; -import org.openecomp.sdc.be.tosca.model.ToscaTemplate; -import org.openecomp.sdc.common.util.YamlToObjectConverter; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Objects; - -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.when; -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; - -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; - private Configuration.EnvironmentContext environmentContext = mock(Configuration.EnvironmentContext.class); - DummyConfigurationManager dummyConfigurationManager = new DummyConfigurationManager(); - private static final Map dataTypes = new HashMap<>(); - - - @BeforeClass - public static void setUp() { - mapper = new ObjectMapper(); - mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); - - } - @Before - public void beforeTest() { - when(environmentContext.getDefaultValue()).thenReturn("General_Revenue-Bearing"); - when(dummyConfigurationManager.getConfigurationMock().getEnvironmentContext()) - .thenReturn(environmentContext); - } - - - @Test - public void addInterfaceTypeElementToResource() { - Component component = new Resource(); - component.setNormalizedName("normalizedComponentName"); - component.setMetadataDefinition(new ServiceMetadataDefinition()); - component.getComponentMetadataDefinition().getMetadataDataDefinition().setName("NodeTypeName"); - component.getComponentMetadataDefinition().getMetadataDataDefinition().setSystemName("NodeTypeName"); - InterfaceDefinition addedInterface = new InterfaceDefinition(); - addedInterface.setType("Local"); - addOperationsToInterface(component, addedInterface, 5, 3, true, false); - final String interfaceType = "normalizedComponentName-interface"; - component.setInterfaces(new HashMap<>()); - component.getInterfaces().put(interfaceType, addedInterface); - final Map interfaceTypeElement = - addInterfaceTypeElement(component, new ArrayList<>()); - - ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null); - ToscaTemplate template = new ToscaTemplate("test"); - template.setInterface_types(interfaceTypeElement); - final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template); - - Assert.assertFalse(toscaRepresentation.getMainYaml().contains("operations")); - Assert.assertTrue(toscaRepresentation.getMainYaml().contains("NodeTypeName")); - } - - @Test - public void addInterfaceTypeElementToService() { - Component component = new Service(); - component.setNormalizedName("normalizedServiceComponentName"); - component.setMetadataDefinition(new ServiceMetadataDefinition()); - component.getComponentMetadataDefinition().getMetadataDataDefinition().setName("NodeTypeName"); - component.getComponentMetadataDefinition().getMetadataDataDefinition().setSystemName("NodeTypeName"); - InterfaceDefinition addedInterface = new InterfaceDefinition(); - addedInterface.setType("Local"); - addOperationsToInterface(component, addedInterface, 5, 3, true, false); - final String interfaceType = "normalizedServiceComponentName-interface"; - component.setInterfaces(new HashMap<>()); - component.getInterfaces().put(interfaceType, addedInterface); - final Map interfaceTypeElement = - addInterfaceTypeElement(component, new ArrayList<>()); - - ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null); - ToscaTemplate template = new ToscaTemplate("testService"); - template.setInterface_types(interfaceTypeElement); - final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template); - - Assert.assertFalse(toscaRepresentation.getMainYaml().contains("operations")); - Assert.assertTrue(toscaRepresentation.getMainYaml().contains("NodeTypeName")); - } - - @Test - public void addInterfaceDefinitionElementToResource() { - Component component = new Resource(); - component.setNormalizedName("normalizedComponentName"); - InterfaceDefinition addedInterface = new InterfaceDefinition(); - addedInterface.setType("com.some.resource.or.other.resourceName"); - - 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(); - addInterfaceDefinitionElement(component, nodeType, dataTypes, false); - - ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null); - ToscaTemplate template = new ToscaTemplate(NODE_TYPE_NAME); - Map nodeTypes = new HashMap<>(); - nodeTypes.put(NODE_TYPE_NAME, nodeType); - template.setNode_types(nodeTypes); - final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template); - - String mainYaml = toscaRepresentation.getMainYaml(); - Assert.assertFalse(mainYaml.contains("operations")); - Assert.assertTrue(mainYaml.contains("resourceName:")); - Assert.assertTrue(mainYaml.contains("inputs:")); - validateOperationInputs(mainYaml, 2, null); - Assert.assertFalse(mainYaml.contains("defaultp")); - Assert.assertTrue(mainYaml.contains("has description")); - Assert.assertTrue(mainYaml.contains(MAPPED_PROPERTY_NAME)); - Assert.assertTrue(mainYaml.contains("com.some.resource.or.other.resourceName")); - } - - @Test - public void addInterfaceDefinitionElementToService() { - Component component = new Service(); - component.setNormalizedName("normalizedServiceComponentName"); - InterfaceDefinition addedInterface = new InterfaceDefinition(); - addedInterface.setType("com.some.service.or.other.serviceName"); - 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(); - addInterfaceDefinitionElement(component, nodeType, dataTypes, false); - - ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null); - ToscaTemplate template = new ToscaTemplate("testService"); - Map nodeTypes = new HashMap<>(); - nodeTypes.put(NODE_TYPE_NAME, nodeType); - template.setNode_types(nodeTypes); - final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template); - String mainYaml = toscaRepresentation.getMainYaml(); - Assert.assertFalse(mainYaml.contains("operations")); - Assert.assertTrue(mainYaml.contains("serviceName:")); - Assert.assertTrue(mainYaml.contains("inputs:")); - validateOperationInputs(mainYaml, 2, null); - Assert.assertFalse(mainYaml.contains("defaultp")); - Assert.assertTrue(mainYaml.contains("has description")); - Assert.assertTrue(mainYaml.contains(MAPPED_PROPERTY_NAME)); - Assert.assertTrue(mainYaml.contains("com.some.service.or.other.serviceName")); - } - - - @Test - public void testGetInterfaceAsMapServiceProxy() { - Component component = new Resource(); - component.setNormalizedName("normalizedComponentName"); - InterfaceDefinition addedInterface = new InterfaceDefinition(); - addedInterface.setToscaResourceName("com.some.resource.or.other.resourceName"); - addedInterface.setType("com.some.resource.or.other.resourceName"); - addOperationsToInterface(component, addedInterface, 3, 2, true, false); - final String interfaceType = "normalizedComponentName-interface"; - component.setInterfaces(new HashMap<>()); - component.getInterfaces().put(interfaceType, addedInterface); - Map interfacesMap = InterfacesOperationsToscaUtil - .getInterfacesMap(component, null, component.getInterfaces(), null, false, true); - ToscaNodeType nodeType = new ToscaNodeType(); - nodeType.setInterfaces(interfacesMap); - ToscaExportHandler handler = new ToscaExportHandler(); - ToscaTemplate template = new ToscaTemplate(NODE_TYPE_NAME); - Map nodeTypes = new HashMap<>(); - nodeTypes.put(NODE_TYPE_NAME, nodeType); - template.setNode_types(nodeTypes); - final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template); - - String mainYaml = toscaRepresentation.getMainYaml(); - Assert.assertFalse(mainYaml.contains("operations")); - Assert.assertTrue(mainYaml.contains("resourceName:")); - Assert.assertTrue(mainYaml.contains("inputs:")); - validateServiceProxyOperationInputs(mainYaml); - Assert.assertFalse(mainYaml.contains("defaultp")); - Assert.assertTrue(mainYaml.contains("has description")); - Assert.assertTrue(mainYaml.contains(MAPPED_PROPERTY_NAME)); - Assert.assertTrue(mainYaml.contains("com.some.resource.or.other.resourceName")); - } - - @Test - public void addInterfaceDefinitionElement_noInputs() { - Component component = new Resource(); - component.setNormalizedName("normalizedComponentName"); - InterfaceDefinition addedInterface = new InterfaceDefinition(); - addedInterface.setType("com.some.resource.or.other.resourceNameNoInputs"); - 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(); - addInterfaceDefinitionElement(component, nodeType, null, false); - - ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null); - ToscaTemplate template = new ToscaTemplate("test"); - Map nodeTypes = new HashMap<>(); - nodeTypes.put("test", nodeType); - template.setNode_types(nodeTypes); - final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template); - - Assert.assertFalse(toscaRepresentation.getMainYaml().contains("operations")); - Assert.assertFalse(toscaRepresentation.getMainYaml().contains(INPUT_NAME_PREFIX)); - Assert.assertFalse(toscaRepresentation.getMainYaml().contains("defaultp")); - Assert.assertTrue(toscaRepresentation.getMainYaml().contains("resourceNameNoInputs:")); - Assert.assertTrue(toscaRepresentation.getMainYaml().contains("has description")); - 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, dataTypes, false); - - ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null); - ToscaTemplate template = new ToscaTemplate("test"); - Map 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"); - } - - @Test - public void addInterfaceDefinitionElementInputMappedToOtherOperationOutputFromOtherInterface() { - 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(opInputDef -> opInputDef.getName().contains("integer")) - .forEach(opInputDef -> opInputDef.setInputId( - addedInterfaceType +".name_for_op_1.output_integer_1"))); - //Mapping to operation from another interface - String secondInterfaceType = "org.test.lifecycle.standard.interfaceType.second"; - InterfaceDefinition secondInterface = new InterfaceDefinition(); - secondInterface.setType(secondInterfaceType); - addOperationsToInterface(component, secondInterface, 2, 2, true, true); - secondInterface.getOperationsMap().values().stream() - .filter(operationInputDefinition -> operationInputDefinition.getName().equalsIgnoreCase( - "name_for_op_0")) - .forEach(operation -> operation.getInputs().getListToscaDataDefinition().stream() - .filter(opInputDef -> opInputDef.getName().contains("integer")) - .forEach(opInputDef -> opInputDef.setInputId( - addedInterfaceType +".name_for_op_1.output_integer_1"))); - component.setInterfaces(new HashMap<>()); - component.getInterfaces().put(addedInterfaceType, addedInterface); - component.getInterfaces().put(secondInterfaceType, secondInterface); - - ToscaNodeType nodeType = new ToscaNodeType(); - addInterfaceDefinitionElement(component, nodeType, dataTypes, false); - - ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null); - ToscaTemplate template = new ToscaTemplate("test"); - Map 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(Component component, InterfaceDefinition addedInterface, int numOfOps, - int numOfInputsPerOp, boolean hasInputs, boolean hasOutputs) { - - addedInterface.setOperations(new HashMap<>()); - for (int i = 0; i < numOfOps; i++) { - final OperationDataDefinition operation = new OperationDataDefinition(); - operation.setName("name_for_op_" + i); - operation.setDescription("op " + i + " has description"); - final ArtifactDataDefinition implementation = new ArtifactDataDefinition(); - implementation.setArtifactName(i + "_createBPMN.bpmn"); - operation.setImplementation(implementation); - if (hasInputs) { - operation.setInputs(createInputs(component, numOfInputsPerOp)); - } - if (hasOutputs) { - operation.setOutputs(createOutputs(addedInterface.getToscaResourceName(), - operation.getName(), numOfInputsPerOp)); - } - addedInterface.getOperations().put(operation.getName(), operation); - } - } - - private ListDataDefinition createInputs(Component component, int numOfInputs) { - ListDataDefinition 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, 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 createOutputs(String interfaceName, - String operationName, - int numOfOutputs) { - ListDataDefinition operationOutputDefinitionList = new ListDataDefinition<>(); - for (int i = 0; i < numOfOutputs; i++) { - operationOutputDefinitionList.add(createMockOperationOutputDefinition(interfaceName, operationName, - OUTPUT_NAME_PREFIX + inputTypes[i] + "_" + i, i)); - } - return operationOutputDefinitionList; - } - - private OperationInputDefinition createMockOperationInputDefinition(String name, String id, int index) { - OperationInputDefinition operationInputDefinition = new OperationInputDefinition(); - operationInputDefinition.setName(name); - operationInputDefinition.setInputId(id); - operationInputDefinition.setType(inputTypes[index]); - operationInputDefinition.setRequired(index % 2 == 0); - Map> toscaDefaultValueMap = new HashMap<>(); - List toscaDefaultValues = new ArrayList<>(); - toscaDefaultValues.add(SELF); - toscaDefaultValues.add(id.substring(id.lastIndexOf('.') + 1)); - toscaDefaultValueMap.put(ToscaFunctions.GET_PROPERTY.getFunctionName(), toscaDefaultValues); - operationInputDefinition.setToscaDefaultValue(new Gson().toJson(toscaDefaultValueMap)); - operationInputDefinition.setSource("ServiceInput"); - return operationInputDefinition; - } - - private OperationOutputDefinition createMockOperationOutputDefinition(String interfaceName, String operationName, - String outputName, int index) { - OperationOutputDefinition operationInputDefinition = new OperationOutputDefinition(); - operationInputDefinition.setName(outputName); - operationInputDefinition.setType(inputTypes[index]); - operationInputDefinition.setRequired(index % 2 == 0); - Map> toscaDefaultValueMap = new HashMap<>(); - List toscaDefaultValues = new ArrayList<>(); - toscaDefaultValues.add(SELF); - toscaDefaultValues.add(interfaceName); - toscaDefaultValues.add(operationName); - toscaDefaultValues.add(outputName); - toscaDefaultValueMap.put(ToscaFunctions.GET_OPERATION_OUTPUT.getFunctionName(), toscaDefaultValues); - 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() - + String.valueOf(numOfInputsPerOp).length()); - YamlToObjectConverter objectConverter = new YamlToObjectConverter(); - ToscaNodeType toscaNodeType = objectConverter.convert(nodeTypesRepresentation.getBytes(), ToscaNodeType.class); - Map interfaces = toscaNodeType.getInterfaces(); - for (Map.Entry interfaceEntry : interfaces.entrySet()) { - Map interfaceDefinition = mapper.convertValue(interfaceEntry.getValue(), Map.class); - for (Map.Entry operationEntry : interfaceDefinition.entrySet()) { - Object operationVal = operationEntry.getValue(); - if (operationVal instanceof Map) { - //Since the inputs are mapped to output operations from only first interface so using that name - validateOperationInputDefinition(interfaces.keySet().iterator().next(), mappedOperationName, - operationVal); - } - } - } - } - - private void validateOperationInputDefinition(String interfaceType, String operationName, Object operationVal) { - Map operation = mapper.convertValue(operationVal, Map.class); - Map inputs = (Map) operation.get("inputs"); - for (Map.Entry inputEntry : inputs.entrySet()) { - String[] inputNameSplit = inputEntry.getKey().split("_"); - Map inputValueObject = (Map) 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 inputValueObject) { - Map mappedInputValue = (Map) inputValueObject.get("default"); - if(mappedInputValue.containsKey(ToscaFunctions.GET_PROPERTY.getFunctionName())) { - String mappedPropertyValue = MAPPED_PROPERTY_NAME + index; - List mappedPropertyDefaultValue = (List) mappedInputValue.get(ToscaFunctions.GET_PROPERTY.getFunctionName()); - Assert.assertEquals(2, mappedPropertyDefaultValue.size()); - Assert.assertTrue(mappedPropertyDefaultValue.contains(SELF)); - Assert.assertTrue(mappedPropertyDefaultValue.contains(mappedPropertyValue)); - } else if(mappedInputValue.containsKey(ToscaFunctions.GET_OPERATION_OUTPUT.getFunctionName())) { - List mappedPropertyDefaultValue = (List) mappedInputValue.get(ToscaFunctions.GET_OPERATION_OUTPUT.getFunctionName()); - 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: "+ ToscaFunctions.GET_PROPERTY.getFunctionName() + - "/"+ ToscaFunctions.GET_OPERATION_OUTPUT.getFunctionName()); - } - } - - private void validateServiceProxyOperationInputs(String mainYaml) { - String nodeTypeKey = NODE_TYPE_NAME + ":"; - String nodeTypesRepresentation = mainYaml.substring(mainYaml.indexOf(nodeTypeKey) + nodeTypeKey.length(), - mainYaml.lastIndexOf(MAPPED_PROPERTY_NAME) + MAPPED_PROPERTY_NAME.length()); - YamlUtil yamlUtil = new YamlUtil(); - ToscaNodeType toscaNodeType = yamlUtil.yamlToObject(nodeTypesRepresentation, ToscaNodeType.class); - for (Object interfaceVal : toscaNodeType.getInterfaces().values()) { - Map interfaceDefinition = mapper.convertValue(interfaceVal, Map.class); - for (Object operationVal : interfaceDefinition.values()) { - if (operationVal instanceof Map) { - Map operation = (Map) mapper.convertValue(operationVal, Map.class); - Map operationInputs = (Map) operation.get("inputs"); - for (Object inputValue : operationInputs.values()) { - Map inputValueAsMap = (Map) inputValue; - Assert.assertFalse(inputValueAsMap.keySet().contains("type")); - Assert.assertFalse(inputValueAsMap.keySet().contains("required")); - Assert.assertFalse(inputValueAsMap.keySet().contains("default")); - } - } - } - } - } - - @Test - public void testAddInterfaceTypeElementGetCorrectLocalInterfaceName() { - Service service = new Service(); - service.setMetadataDefinition(new ServiceMetadataDefinition()); - service.getComponentMetadataDefinition().getMetadataDataDefinition().setName("LocalInterface"); - service.getComponentMetadataDefinition().getMetadataDataDefinition().setSystemName("LocalInterface"); - service.setInterfaces(Collections.singletonMap("Local", new InterfaceDefinition("Local", null, new HashMap<>()))); - - Map resultMap = InterfacesOperationsToscaUtil.addInterfaceTypeElement(service, - Collections.singletonList("org.openecomp.interfaces.node.lifecycle.Standard")); - - Assert.assertTrue(MapUtils.isNotEmpty(resultMap) - && resultMap.containsKey("org.openecomp.interfaces.node.lifecycle.LocalInterface")); - } - - @Test - public void testAddInterfaceTypeElementNoTypeChangeIfNotLocal() { - Service service = new Service(); - service.setMetadataDefinition(new ServiceMetadataDefinition()); - service.getComponentMetadataDefinition().getMetadataDataDefinition().setName("LocalInterface"); - service.setInterfaces(Collections.singletonMap("NotLocal", new InterfaceDefinition("NotLocal", null, - new HashMap<>()))); - - Map resultMap = InterfacesOperationsToscaUtil.getInterfacesMap(service, null, - service.getInterfaces(), null, false, false); - - Assert.assertTrue(MapUtils.isNotEmpty(resultMap) - && resultMap.containsKey("NotLocal")); - } -} -- cgit 1.2.3-korg