diff options
Diffstat (limited to 'catalog-be/src/test/java')
| -rw-r--r-- | catalog-be/src/test/java/org/openecomp/sdc/be/components/ResourceImportManagerTest.java | 64 | ||||
| -rw-r--r-- | catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ImportUtilsTest.java | 8 | ||||
| -rw-r--r-- | catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InterfaceDefinitionHandlerTest.java | 174 | ||||
| -rw-r--r-- | catalog-be/src/test/java/org/openecomp/sdc/be/tosca/InterfacesOperationsConverterTest.java (renamed from catalog-be/src/test/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsConverterTest.java) | 240 | ||||
| -rw-r--r-- | catalog-be/src/test/java/org/openecomp/sdc/be/tosca/model/ToscaInterfaceDefinitionTest.java | 72 |
5 files changed, 382 insertions, 176 deletions
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/ResourceImportManagerTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/ResourceImportManagerTest.java index b497253118..336b8ec940 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/ResourceImportManagerTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/ResourceImportManagerTest.java @@ -22,7 +22,20 @@ package org.openecomp.sdc.be.components; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertSame; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.when; + import fj.data.Either; +import java.io.IOException; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; import org.apache.commons.lang3.tuple.ImmutablePair; import org.junit.Before; import org.junit.BeforeClass; @@ -32,6 +45,7 @@ import org.mockito.stubbing.Answer; import org.openecomp.sdc.be.auditing.impl.AuditingManager; import org.openecomp.sdc.be.components.impl.ImportUtils; import org.openecomp.sdc.be.components.impl.ImportUtilsTest; +import org.openecomp.sdc.be.components.impl.InterfaceDefinitionHandler; import org.openecomp.sdc.be.components.impl.InterfaceOperationBusinessLogic; import org.openecomp.sdc.be.components.impl.ResourceBusinessLogic; import org.openecomp.sdc.be.components.impl.ResourceImportManager; @@ -63,27 +77,15 @@ import org.openecomp.sdc.common.impl.FSConfigurationSource; import org.openecomp.sdc.exception.PolicyException; import org.openecomp.sdc.exception.ResponseFormat; -import java.io.IOException; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertSame; -import static org.junit.Assert.assertTrue; -import static org.mockito.Mockito.when; - public class ResourceImportManagerTest { - private static ConfigurationManager configurationManager; static ResourceImportManager importManager; static AuditingManager auditingManager = Mockito.mock(AuditingManager.class); static ResponseFormatManager responseFormatManager = Mockito.mock(ResponseFormatManager.class); static ResourceBusinessLogic resourceBusinessLogic = Mockito.mock(ResourceBusinessLogic.class); static InterfaceOperationBusinessLogic interfaceOperationBusinessLogic = Mockito.mock(InterfaceOperationBusinessLogic.class); + static InterfaceDefinitionHandler interfaceDefinitionHandler = + new InterfaceDefinitionHandler(interfaceOperationBusinessLogic); static UserBusinessLogic userAdmin = Mockito.mock(UserBusinessLogic.class); static ToscaOperationFacade toscaOperationFacade = Mockito.mock(ToscaOperationFacade.class); @@ -93,17 +95,16 @@ public class ResourceImportManagerTest { @BeforeClass public static void beforeClass() { - importManager = new ResourceImportManager(componentsUtils, capabilityTypeOperation); + importManager = new ResourceImportManager(componentsUtils, capabilityTypeOperation, interfaceDefinitionHandler); importManager.setAuditingManager(auditingManager); when(toscaOperationFacade.getLatestByToscaResourceName(Mockito.anyString())).thenReturn(Either.left(null)); importManager.setResponseFormatManager(responseFormatManager); importManager.setResourceBusinessLogic(resourceBusinessLogic); - importManager.setInterfaceOperationBusinessLogic(interfaceOperationBusinessLogic); importManager.setToscaOperationFacade(toscaOperationFacade); String appConfigDir = "src/test/resources/config/catalog-be"; ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir); - configurationManager = new ConfigurationManager(configurationSource); + final ConfigurationManager configurationManager = new ConfigurationManager(configurationSource); Configuration configuration = new Configuration(); configuration.setJanusGraphInMemoryGraph(true); @@ -223,8 +224,9 @@ public class ResourceImportManagerTest { interfaceTypes.put("tosca.interfaces.node.lifecycle.standard", interfaceDefinition); when(interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(interfaceTypes)); - ImmutablePair<Resource, ActionStatus> createResource = importManager.importNormativeResource(jsonContent, resourceMD, user, true, true); - testSetInterfaceImplementation(createResource.left); + final ImmutablePair<Resource, ActionStatus> createResource = importManager + .importNormativeResource(jsonContent, resourceMD, user, true, true); + assertSetInterfaceImplementation(createResource.left); } @Test @@ -342,12 +344,12 @@ public class ResourceImportManagerTest { assertTrue(properties.containsKey("volume_id")); propertyDefinition = properties.get("volume_id"); assertEquals("string", propertyDefinition.getType()); - assertTrue(!propertyDefinition.isRequired()); + assertFalse(propertyDefinition.isRequired()); assertTrue(properties.containsKey("snapshot_id")); propertyDefinition = properties.get("snapshot_id"); assertEquals("string", propertyDefinition.getType()); - assertTrue(!propertyDefinition.isRequired()); + assertFalse(propertyDefinition.isRequired()); } @@ -398,20 +400,19 @@ public class ResourceImportManagerTest { } - private void testSetInterfaceImplementation(Resource resource) { - Map<String, InterfaceDefinition> interfaces = resource.getInterfaces(); + private void assertSetInterfaceImplementation(final Resource resource) { + final Map<String, InterfaceDefinition> interfaces = resource.getInterfaces(); assertEquals(1, interfaces.size()); assertTrue(interfaces.containsKey("Standard")); - - InterfaceDefinition interfaceDefinition = interfaces.get("Standard"); + + final InterfaceDefinition interfaceDefinition = interfaces.get("Standard"); assertEquals("tosca.interfaces.node.lifecycle.Standard", interfaceDefinition.getType()); assertEquals("tosca.interfaces.node.lifecycle.standard", interfaceDefinition.getUniqueId()); - Map<String, OperationDataDefinition> operations = interfaceDefinition.getOperations(); + final Map<String, OperationDataDefinition> operations = interfaceDefinition.getOperations(); assertEquals(1, operations.size()); - OperationDataDefinition operation = operations.get("configure"); + final OperationDataDefinition operation = operations.get("configure"); assertEquals("'camunda/vnfConfigure'", operation.getImplementation().getArtifactName()); - } private void testSetDerivedFrom(Resource resource) { @@ -421,19 +422,12 @@ public class ResourceImportManagerTest { } private void testSetMetaDataFromJson(Resource resource, UploadResourceInfo resourceMD) { - - // assertTrue( resource.getCategory().equals(resourceMD.getCategory()) - // ); assertEquals(resource.getDescription(), resourceMD.getDescription()); assertEquals(resource.getIcon(), resourceMD.getResourceIconPath()); assertEquals(resource.getName(), resourceMD.getName()); assertEquals(resource.getResourceVendorModelNumber(), resourceMD.getResourceVendorModelNumber()); assertEquals(resource.getContactId(), resourceMD.getContactId()); assertEquals(resource.getCreatorUserId(), resourceMD.getContactId()); - - // assertTrue( resource.isAbstract() == - // Constants.ABSTRACT_CATEGORY.equals(resourceMD.getCategory())); - assertEquals(resourceMD.getTags().size(), resource.getTags().size()); for (String tag : resource.getTags()) { assertTrue(resourceMD.getTags().contains(tag)); diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ImportUtilsTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ImportUtilsTest.java index 87875d8f20..9cd095b5b5 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ImportUtilsTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ImportUtilsTest.java @@ -324,7 +324,7 @@ public class ImportUtilsTest { PropertyDefinition property = properties.get("service_type"); assertTrue(property.getConstraints()!= null && property.getConstraints().size() == 1); assertTrue(property.getConstraints().get(0) instanceof ValidValuesConstraint); - assertTrue(((ValidValuesConstraint) property.getConstraints().get(0)).getValidValues() != null); + assertNotNull(((ValidValuesConstraint) property.getConstraints().get(0)).getValidValues()); List<String> validValues = ((ValidValuesConstraint) property.getConstraints().get(0)).getValidValues(); assertTrue(validValues.containsAll(Lists.newArrayList("firewall", "analyzer", "source-nat", "loadbalancer"))); @@ -334,7 +334,7 @@ public class ImportUtilsTest { PropertyDefinition innerProperty = new PropertyDefinition(property.getSchema().getProperty()); List<PropertyConstraint> innerConstraints = innerProperty.getConstraints(); assertTrue(innerConstraints.get(0) instanceof ValidValuesConstraint); - assertTrue(((ValidValuesConstraint) innerConstraints.get(0)).getValidValues() != null); + assertNotNull(((ValidValuesConstraint) innerConstraints.get(0)).getValidValues()); validValues = ((ValidValuesConstraint) innerConstraints.get(0)).getValidValues(); assertTrue(validValues.containsAll(Lists.newArrayList("management", "left", "right", "other"))); } @@ -352,6 +352,10 @@ public class ImportUtilsTest { Map<String, Map<String, Object>> expectedProperties = getElements(toscaJson, TypeUtils.ToscaTagNamesEnum.INPUTS); compareProperties(expectedProperties, actualInputs.left().value()); + actualInputs = ImportUtils.getInputs(toscaJson); + assertTrue(actualInputs.isLeft()); + expectedProperties = getElements(toscaJson, TypeUtils.ToscaTagNamesEnum.INPUTS); + compareProperties(expectedProperties, actualInputs.left().value()); } private void compareAttributes(Map<String, Map<String, Object>> expected, Map<String, AttributeDataDefinition> actual) { diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InterfaceDefinitionHandlerTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InterfaceDefinitionHandlerTest.java new file mode 100644 index 0000000000..f819eceb43 --- /dev/null +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InterfaceDefinitionHandlerTest.java @@ -0,0 +1,174 @@ +/* + * ============LICENSE_START======================================================= + * Copyright (C) 2020 Nordix Foundation + * ================================================================================ + * 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. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.components.impl; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.aMapWithSize; +import static org.hamcrest.Matchers.containsInAnyOrder; +import static org.hamcrest.Matchers.equalTo; +import static org.hamcrest.Matchers.hasItems; +import static org.hamcrest.Matchers.hasSize; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; +import static org.mockito.Mockito.when; + +import fj.data.Either; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; +import org.apache.commons.collections.MapUtils; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.InputDataDefinition; +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.model.InterfaceDefinition; +import org.yaml.snakeyaml.Yaml; + +@ExtendWith(MockitoExtension.class) +class InterfaceDefinitionHandlerTest { + + @Mock + private InterfaceOperationBusinessLogic interfaceOperationBusinessLogic; + private InterfaceDefinitionHandler interfaceDefinitionHandler; + private InterfaceDefinition interfaceLifecyleStandard; + private static final Path TEST_RESOURCE_PATH = Paths.get("src/test/resources/interfaceDefinition"); + private static final String CREATE_OPERATION = "create"; + private static final String DELETE_OPERATION = "delete"; + private static final String START_OPERATION = "start"; + private static final String STOP_OPERATION = "stop"; + private static final String INTERFACE_TYPE = "tosca.interfaces.node.lifecycle.Standard"; + + @BeforeEach + void setUp() { + interfaceDefinitionHandler = new InterfaceDefinitionHandler(interfaceOperationBusinessLogic); + mockAllInterfacesLifecycle(); + } + + private void mockAllInterfacesLifecycle() { + final Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>(); + interfaceLifecyleStandard = new InterfaceDefinition(); + interfaceLifecyleStandard.setType(INTERFACE_TYPE); + final Map<String, OperationDataDefinition> operations = new HashMap<>(); + operations.put(CREATE_OPERATION, new OperationDataDefinition()); + operations.put(START_OPERATION, new OperationDataDefinition()); + operations.put(STOP_OPERATION, new OperationDataDefinition()); + operations.put(DELETE_OPERATION, new OperationDataDefinition()); + interfaceLifecyleStandard.setOperations(operations); + interfaceTypes.put(INTERFACE_TYPE, interfaceLifecyleStandard); + when(interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(interfaceTypes)); + } + + @Test + void testCreateWithLegacyOperationDeclarationSuccess() throws FileNotFoundException { + final Map<String, Object> load = loadYaml(Paths.get("interfaceDefinition-legacy.yaml")); + final InterfaceDefinition actualInterfaceDefinition = interfaceDefinitionHandler.create(load); + assertInterfaceDefinition(actualInterfaceDefinition); + } + + @Test + void testCreateWithOperationSuccess() throws FileNotFoundException { + final Map<String, Object> load = loadYaml(Paths.get("interfaceDefinition-tosca1.3.yaml")); + final InterfaceDefinition actualInterfaceDefinition = interfaceDefinitionHandler.create(load); + assertInterfaceDefinition(actualInterfaceDefinition); + } + + private void assertInterfaceDefinition(final InterfaceDefinition actualInterfaceDefinition) { + interfaceLifecyleStandard.getOperations().keySet().forEach(operation -> + assertTrue(actualInterfaceDefinition.hasOperation(operation))); + assertThat("Interface type should be as expected", actualInterfaceDefinition.getType(), + equalTo(actualInterfaceDefinition.getType())); + assertThat("Interface should contain 2 inputs", actualInterfaceDefinition.getInputs(), aMapWithSize(2)); + assertThat("Interface inputs should be as expected", actualInterfaceDefinition.getInputs().keySet(), + containsInAnyOrder("stringInput", "actionInput")); + + final InputDataDefinition stringInput = actualInterfaceDefinition.getInputs().get("stringInput"); + assertInput("string", "stringInput description", true, "defaultValue", "aStatus", stringInput); + final InputDataDefinition actionInput = actualInterfaceDefinition.getInputs().get("actionInput"); + assertInput("org.openecomp.resource.datatypes.Action", null, false, null, null, actionInput); + + final OperationDataDefinition createOperation = actualInterfaceDefinition.getOperations().get(CREATE_OPERATION); + assertOperation("'camunda/serviceSelect'", createOperation); + + final OperationDataDefinition deleteOperation = actualInterfaceDefinition.getOperations().get(DELETE_OPERATION); + assertOperation("'camunda/serviceDeselect'", deleteOperation); + + final Map<String, String> expectedInputMap = new HashMap<>(); + expectedInputMap.put("action", "org.openecomp.resource.datatypes.Action"); + final OperationDataDefinition startOperation = actualInterfaceDefinition.getOperations().get(START_OPERATION); + assertOperation("'camunda/executeAction'", expectedInputMap, startOperation); + final OperationDataDefinition stopOperation = actualInterfaceDefinition.getOperations().get(STOP_OPERATION); + assertOperation("'camunda/executeAction'", expectedInputMap, stopOperation); + } + + private void assertOperation(final String implementation, final OperationDataDefinition actualOperation) { + assertOperation(implementation, Collections.emptyMap(), actualOperation); + } + + private void assertOperation(final String implementation, final Map<String, String> inputNameTypeMap, + final OperationDataDefinition actualOperation) { + final ArtifactDataDefinition artifactDefinition = actualOperation.getImplementation(); + assertThat("Implementation should be as expected", artifactDefinition.getArtifactName(), equalTo(implementation)); + final ListDataDefinition<OperationInputDefinition> inputListDataDef = actualOperation.getInputs(); + if (inputListDataDef == null) { + if (MapUtils.isNotEmpty(inputNameTypeMap)) { + final String expectedInputNames = String.join(",", inputNameTypeMap.keySet()); + fail(String.format("No inputs were found, but some inputs are expected: %s", expectedInputNames)); + } + return; + } + + final String msgFormat = "Operation should have %s"; + final List<OperationInputDefinition> inputList = inputListDataDef.getListToscaDataDefinition(); + assertThat(String.format(msgFormat, "the expected quantity of inputs"), inputList, hasSize(inputNameTypeMap.size())); + + final List<String> inputNames = inputList.stream() + .map(OperationInputDefinition::getName).collect(Collectors.toList()); + + assertThat(String.format(msgFormat, "the expected inputs"), inputNames, + hasItems(inputNameTypeMap.keySet().toArray(new String[0]))); + } + + private void assertInput(final String type, final String description, final Boolean required, + final String defaultValue, final String status, final InputDataDefinition actualInput) { + assertThat("Input type should be as expected", type, equalTo(actualInput.getType())); + assertThat("Input description should be as expected", description, equalTo(actualInput.getDescription())); + assertThat("Input required should be as expected", required, equalTo(required != null && required)); + assertThat("Input default should be as expected", defaultValue, equalTo(actualInput.getDefaultValue())); + assertThat("Input status should be as expected", status, equalTo(actualInput.getStatus())); + } + + private Map<String, Object> loadYaml(final Path filePathFromResource) throws FileNotFoundException { + final Path filePath = Paths.get(TEST_RESOURCE_PATH.toString(), filePathFromResource.toString()); + final FileInputStream fileInputStream = new FileInputStream(filePath.toString()); + return (Map<String, Object>) new Yaml().load(fileInputStream); + } +}
\ No newline at end of file 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/InterfacesOperationsConverterTest.java index 93a45ad20f..0281317b89 100644 --- 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/InterfacesOperationsConverterTest.java @@ -1,24 +1,42 @@ /* - * Copyright © 2016-2018 European Support Limited + * ============LICENSE_START======================================================= + * Copyright (C) 2020 Nordix Foundation + * ================================================================================ + * 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 * - * 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. * - * 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. + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= */ -package org.openecomp.sdc.be.tosca.utils; - -import static org.mockito.Mockito.mock; +package org.openecomp.sdc.be.tosca; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.allOf; +import static org.hamcrest.Matchers.containsInAnyOrder; +import static org.hamcrest.Matchers.containsString; +import static org.hamcrest.Matchers.equalTo; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; import static org.openecomp.sdc.be.tosca.InterfacesOperationsConverter.SELF; import static org.openecomp.sdc.be.tosca.InterfacesOperationsConverter.addInterfaceTypeElement; +import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DEFAULT; +import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DESCRIPTION; +import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.INPUTS; +import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.INTERFACES; +import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.NODE_TYPES; +import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.REQUIRED; +import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.TYPE; import com.fasterxml.jackson.databind.DeserializationFeature; import com.fasterxml.jackson.databind.ObjectMapper; @@ -28,23 +46,23 @@ import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.Map.Entry; import java.util.Objects; import java.util.function.Function; +import java.util.stream.Collectors; 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.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.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.InputDataDefinition; 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.datatypes.elements.PropertyDataDefinition; import org.openecomp.sdc.be.model.Component; import org.openecomp.sdc.be.model.DataTypeDefinition; import org.openecomp.sdc.be.model.InputDefinition; @@ -52,44 +70,40 @@ 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.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 org.openecomp.sdc.tosca.datatypes.ToscaFunctions; +import org.yaml.snakeyaml.Yaml; -@RunWith(MockitoJUnitRunner.class) -public class InterfacesOperationsConverterTest { +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 final 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<String, DataTypeDefinition> dataTypes = new HashMap<>(); private InterfacesOperationsConverter interfacesOperationsConverter; - @BeforeClass + @BeforeAll public static void setUp() { + //initialize the static configuration manager + new DummyConfigurationManager(); mapper = new ObjectMapper(); mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); } - @Before + @BeforeEach public void setUpBeforeTest() { interfacesOperationsConverter = new InterfacesOperationsConverter(new PropertyConvertor()); } @Test - public void addInterfaceTypeElementToResource() { + void addInterfaceTypeElementToResource() { Component component = new Resource(); component.setNormalizedName("normalizedComponentName"); component.setComponentMetadataDefinition(new ServiceMetadataDefinition()); @@ -110,14 +124,14 @@ public class InterfacesOperationsConverterTest { template.setInterface_types(interfaceTypeElement); final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template); - Assert.assertTrue(all( + assertTrue(all( containsAll("NodeTypeName"), containsNone("operations") ).apply(new String(toscaRepresentation.getMainYaml()))); } @Test - public void addInterfaceTypeElementToService() { + void addInterfaceTypeElementToService() { Component component = new Service(); component.setNormalizedName("normalizedServiceComponentName"); component.setComponentMetadataDefinition(new ServiceMetadataDefinition()); @@ -138,14 +152,14 @@ public class InterfacesOperationsConverterTest { template.setInterface_types(interfaceTypeElement); final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template); - Assert.assertTrue(all( + assertTrue(all( containsAll("NodeTypeName"), containsNone("operations") ).apply(new String(toscaRepresentation.getMainYaml()))); } @Test - public void addInterfaceDefinitionElementToResource() { + void addInterfaceDefinitionElementToResource() { Component component = new Resource(); component.setNormalizedName("normalizedComponentName"); InterfaceDefinition addedInterface = new InterfaceDefinition(); @@ -167,7 +181,7 @@ public class InterfacesOperationsConverterTest { final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template); String mainYaml = new String(toscaRepresentation.getMainYaml()); - Assert.assertTrue(all( + assertTrue(all( containsAll("resourceName:", "inputs:", "has description", MAPPED_PROPERTY_NAME, "com.some.resource.or.other.resourceName"), containsNone("operations", "defaultp") ).apply(mainYaml)); @@ -176,7 +190,7 @@ public class InterfacesOperationsConverterTest { } @Test - public void addInterfaceDefinitionElementToService() { + void addInterfaceDefinitionElementToService() { Component component = new Service(); component.setNormalizedName("normalizedServiceComponentName"); InterfaceDefinition addedInterface = new InterfaceDefinition(); @@ -196,7 +210,7 @@ public class InterfacesOperationsConverterTest { template.setNode_types(nodeTypes); final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template); String mainYaml = new String(toscaRepresentation.getMainYaml()); - Assert.assertTrue(all( + assertTrue(all( containsAll("serviceName", "inputs:", "has description", MAPPED_PROPERTY_NAME, "com.some.service.or.other.serviceName"), containsNone("operations", "defaultp") ).apply(mainYaml)); @@ -205,7 +219,7 @@ public class InterfacesOperationsConverterTest { @Test - public void testGetInterfaceAsMapServiceProxy() { + void testGetInterfaceAsMapServiceProxy() { Component component = new Resource(); component.setNormalizedName("normalizedComponentName"); InterfaceDefinition addedInterface = new InterfaceDefinition(); @@ -227,7 +241,7 @@ public class InterfacesOperationsConverterTest { final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template); String mainYaml = new String(toscaRepresentation.getMainYaml()); - Assert.assertTrue(all( + assertTrue(all( containsAll("resourceName:", "inputs:", "has description", MAPPED_PROPERTY_NAME, "com.some.resource.or.other.resourceName"), containsNone("operations", "defaultp") ).apply(mainYaml)); @@ -235,7 +249,7 @@ public class InterfacesOperationsConverterTest { } @Test - public void addInterfaceDefinitionElement_noInputs() { + void addInterfaceDefinitionElement_noInputs() { Component component = new Resource(); component.setNormalizedName("normalizedComponentName"); InterfaceDefinition addedInterface = new InterfaceDefinition(); @@ -255,14 +269,14 @@ public class InterfacesOperationsConverterTest { template.setNode_types(nodeTypes); final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template); - Assert.assertTrue(all( + assertTrue(all( containsAll("resourceNameNoInputs", "has description", "com.some.resource.or.other.resourceName"), containsNone("operations", INPUT_NAME_PREFIX, "defaultp") ).apply(new String(toscaRepresentation.getMainYaml()))); } @Test - public void addInterfaceDefinitionElementInputMappedToOtherOperationOutput() { + void addInterfaceDefinitionElementInputMappedToOtherOperationOutput() { String addedInterfaceType = "com.some.resource.or.other.resourceNameInputMappedToOutput"; Component component = new Resource(); component.setNormalizedName("normalizedComponentName"); @@ -289,7 +303,7 @@ public class InterfacesOperationsConverterTest { template.setNode_types(nodeTypes); final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template); String mainYaml = new String(toscaRepresentation.getMainYaml()); - Assert.assertTrue(all( + assertTrue(all( containsAll("resourceNameInputMappedToOutput:", "inputs:"), containsNone("operations") ).apply(mainYaml)); @@ -297,7 +311,7 @@ public class InterfacesOperationsConverterTest { } @Test - public void addInterfaceDefinitionElementInputMappedToOtherOperationOutputFromOtherInterface() { + void addInterfaceDefinitionElementInputMappedToOtherOperationOutputFromOtherInterface() { String addedInterfaceType = "com.some.resource.or.other.resourceNameInputMappedToOutput"; Component component = new Resource(); component.setNormalizedName("normalizedComponentName"); @@ -339,13 +353,83 @@ public class InterfacesOperationsConverterTest { final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template); String mainYaml = new String(toscaRepresentation.getMainYaml()); - Assert.assertTrue(all( + assertTrue(all( containsAll("resourceNameInputMappedToOutput:", "inputs:"), containsNone("operations") ).apply(mainYaml)); validateOperationInputs(mainYaml, 2, "name_for_op_1"); } + @Test + void interfaceWithInputsToscaExportTest() { + final Component component = new Service(); + final InterfaceDefinition aInterfaceWithInput = new InterfaceDefinition(); + final String interfaceName = "myInterfaceName"; + final String interfaceType = "my.type." + interfaceName; + aInterfaceWithInput.setType(interfaceType); + final String input1Name = "input1"; + final InputDataDefinition input1 = createInput("string", "input1 description", false, "input1 value"); + final String input2Name = "input2"; + final InputDataDefinition input2 = createInput("string", "input2 description", true, "input2 value"); + final Map<String, InputDataDefinition> inputMap = new HashMap<>(); + inputMap.put(input1Name, input1); + inputMap.put(input2Name, input2); + aInterfaceWithInput.setInputs(inputMap); + component.setInterfaces(new HashMap<>()); + component.getInterfaces().put(interfaceName, aInterfaceWithInput); + final ToscaNodeType nodeType = new ToscaNodeType(); + interfacesOperationsConverter.addInterfaceDefinitionElement(component, nodeType, dataTypes, false); + final ToscaExportHandler handler = new ToscaExportHandler(null, null, null, null, null, null, null, null, + interfacesOperationsConverter); + final ToscaTemplate template = new ToscaTemplate("testService"); + final Map<String, ToscaNodeType> nodeTypes = new HashMap<>(); + nodeTypes.put(NODE_TYPE_NAME, nodeType); + template.setNode_types(nodeTypes); + final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template); + final String toscaTemplateYaml = new String(toscaRepresentation.getMainYaml()); + assertThat(toscaTemplateYaml, allOf(containsString(INPUTS.getElementName() + ":"), containsString(input1Name), containsString(interfaceName))); + validateInterfaceInputs(toscaTemplateYaml, interfaceName, inputMap); + } + + private void validateInterfaceInputs(final String yaml, final String interfaceName, final Map<String, InputDataDefinition> expectedInputMap) { + String fixedMainYaml = yaml; + final String nullString = "null"; + if (fixedMainYaml.startsWith(nullString)) { + fixedMainYaml = yaml.substring(nullString.length()); + } + if (fixedMainYaml.endsWith(nullString)) { + fixedMainYaml = fixedMainYaml.substring(0, fixedMainYaml.length() - nullString.length()); + } + final Map<String, Object> yamlMap = (Map<String, Object>) new Yaml().load(fixedMainYaml); + final Map<String, Object> nodeTypesMap = (Map<String, Object>) yamlMap.get(NODE_TYPES.getElementName()); + final Map<String, Object> node = (Map<String, Object>) nodeTypesMap.get(NODE_TYPE_NAME); + final Map<String, Object> interfacesMap = (Map<String, Object>) node.get(INTERFACES.getElementName()); + final Map<String, Object> interface1 = (Map<String, Object>) interfacesMap.get(interfaceName); + final Map<String, Object> actualInputsMap = (Map<String, Object>) interface1.get(INPUTS.getElementName()); + assertThat(actualInputsMap.keySet(), containsInAnyOrder(expectedInputMap.keySet().toArray())); + expectedInputMap.forEach((inputName, inputDataDefinition) -> { + final Map<String, Object> actualInput = (Map<String, Object>) actualInputsMap.get(inputName); + compareInputYaml(inputName, actualInput, inputDataDefinition); + }); + } + + private void compareInputYaml(final String inputName, final Map<String, Object> actualInput, + final InputDataDefinition expectedInput) { + final String msgFormat = "%s should be equal in input %s"; + String field = TYPE.getElementName(); + assertThat(String.format(msgFormat, field, inputName), + actualInput.get(field), equalTo(expectedInput.getType())); + field = DESCRIPTION.getElementName(); + assertThat(String.format(msgFormat, field, inputName), + actualInput.get(field), equalTo(expectedInput.getDescription())); + field = REQUIRED.getElementName(); + assertThat(String.format(msgFormat, field, inputName), + actualInput.get(field), equalTo(expectedInput.getRequired())); + field = DEFAULT.getElementName(); + assertThat(String.format(msgFormat, field, inputName), + actualInput.get(field), equalTo(expectedInput.getDefaultValue())); + } + @FunctionalInterface interface MainYamlAssertion extends Function<String, Boolean> {} @@ -383,6 +467,24 @@ public class InterfacesOperationsConverterTest { } } + private InputDataDefinition createInput(final String type, final String description, final Boolean isRequired, + final String defaultValue) { + final PropertyDataDefinition propertyDataDefinition = new PropertyDataDefinition(); + if (type != null) { + propertyDataDefinition.setType(type); + } + if (description != null) { + propertyDataDefinition.setDescription(description); + } + if (defaultValue != null) { + propertyDataDefinition.setDefaultValue(defaultValue); + } + if (isRequired != null) { + propertyDataDefinition.setRequired(isRequired); + } + return new InputDataDefinition(propertyDataDefinition); + } + private ListDataDefinition<OperationInputDefinition> createInputs(Component component, int numOfInputs) { ListDataDefinition<OperationInputDefinition> operationInputDefinitionList = new ListDataDefinition<>(); for (int i = 0; i < numOfInputs; i++) { @@ -458,7 +560,11 @@ public class InterfacesOperationsConverterTest { Map<String, Object> interfaces = toscaNodeType.getInterfaces(); for (Map.Entry<String, Object> interfaceEntry : interfaces.entrySet()) { Map<String, Object> interfaceDefinition = mapper.convertValue(interfaceEntry.getValue(), Map.class); - for (Map.Entry<String, Object> operationEntry : interfaceDefinition.entrySet()) { + final Map<String, Object> operationsMap = interfaceDefinition.entrySet().stream() + .filter(entry -> !INPUTS.getElementName().equals(entry.getKey()) && + !TYPE.getElementName().equals(entry.getKey())) + .collect(Collectors.toMap(Entry::getKey, Entry::getValue)); + for (Map.Entry<String, Object> operationEntry : operationsMap.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 @@ -475,9 +581,9 @@ public class InterfacesOperationsConverterTest { for (Map.Entry<String, Object> inputEntry : inputs.entrySet()) { String[] inputNameSplit = inputEntry.getKey().split("_"); Map<String, Object> inputValueObject = (Map<String, Object>) inputEntry.getValue(); - Assert.assertEquals(inputNameSplit[1], inputValueObject.get("type")); + assertEquals(inputNameSplit[1], inputValueObject.get("type")); Boolean expectedIsRequired = Integer.parseInt(inputNameSplit[2]) % 2 == 0; - Assert.assertEquals(expectedIsRequired, inputValueObject.get("required")); + assertEquals(expectedIsRequired, inputValueObject.get("required")); validateOperationInputDefinitionDefaultValue(interfaceType, operationName, inputNameSplit[1], Integer.parseInt(inputNameSplit[2]), inputValueObject); } @@ -491,19 +597,19 @@ public class InterfacesOperationsConverterTest { if(mappedInputValue.containsKey(ToscaFunctions.GET_PROPERTY.getFunctionName())) { String mappedPropertyValue = MAPPED_PROPERTY_NAME + index; List<String> mappedPropertyDefaultValue = (List<String>) mappedInputValue.get(ToscaFunctions.GET_PROPERTY.getFunctionName()); - Assert.assertEquals(2, mappedPropertyDefaultValue.size()); - Assert.assertTrue(mappedPropertyDefaultValue.contains(SELF)); - Assert.assertTrue(mappedPropertyDefaultValue.contains(mappedPropertyValue)); + assertEquals(2, mappedPropertyDefaultValue.size()); + assertTrue(mappedPropertyDefaultValue.contains(SELF)); + assertTrue(mappedPropertyDefaultValue.contains(mappedPropertyValue)); } else if(mappedInputValue.containsKey(ToscaFunctions.GET_OPERATION_OUTPUT.getFunctionName())) { List<String> mappedPropertyDefaultValue = (List<String>) mappedInputValue.get(ToscaFunctions.GET_OPERATION_OUTPUT.getFunctionName()); - Assert.assertEquals(4, mappedPropertyDefaultValue.size()); + 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)); + assertTrue(mappedPropertyDefaultValue.contains(SELF)); + assertTrue(mappedPropertyDefaultValue.contains(interfaceType)); + assertTrue(mappedPropertyDefaultValue.contains(operationName)); + assertTrue(mappedPropertyDefaultValue.contains(mappedPropertyValue)); } else { - Assert.fail("Invalid Tosca function in default value. Allowed values: "+ ToscaFunctions.GET_PROPERTY.getFunctionName() + + fail("Invalid Tosca function in default value. Allowed values: "+ ToscaFunctions.GET_PROPERTY.getFunctionName() + "/"+ ToscaFunctions.GET_OPERATION_OUTPUT.getFunctionName()); } } @@ -522,9 +628,9 @@ public class InterfacesOperationsConverterTest { Map<String, Object> operationInputs = (Map<String, Object>) operation.get("inputs"); for (Object inputValue : operationInputs.values()) { Map<String, Object> inputValueAsMap = (Map<String, Object>) inputValue; - Assert.assertFalse(inputValueAsMap.keySet().contains("type")); - Assert.assertFalse(inputValueAsMap.keySet().contains("required")); - Assert.assertFalse(inputValueAsMap.keySet().contains("default")); + assertFalse(inputValueAsMap.keySet().contains("type")); + assertFalse(inputValueAsMap.keySet().contains("required")); + assertFalse(inputValueAsMap.keySet().contains("default")); } } } @@ -532,7 +638,7 @@ public class InterfacesOperationsConverterTest { } @Test - public void testAddInterfaceTypeElementGetCorrectLocalInterfaceName() { + void testAddInterfaceTypeElementGetCorrectLocalInterfaceName() { Service service = new Service(); service.setComponentMetadataDefinition(new ServiceMetadataDefinition()); service.getComponentMetadataDefinition().getMetadataDataDefinition().setName("LocalInterface"); @@ -542,12 +648,12 @@ public class InterfacesOperationsConverterTest { Map<String, Object> resultMap = InterfacesOperationsConverter.addInterfaceTypeElement(service, Collections.singletonList("org.openecomp.interfaces.node.lifecycle.Standard")); - Assert.assertTrue(MapUtils.isNotEmpty(resultMap) + assertTrue(MapUtils.isNotEmpty(resultMap) && resultMap.containsKey("org.openecomp.interfaces.node.lifecycle.LocalInterface")); } @Test - public void testAddInterfaceTypeElementNoTypeChangeIfNotLocal() { + void testAddInterfaceTypeElementNoTypeChangeIfNotLocal() { Service service = new Service(); service.setComponentMetadataDefinition(new ServiceMetadataDefinition()); service.getComponentMetadataDefinition().getMetadataDataDefinition().setName("LocalInterface"); @@ -557,7 +663,7 @@ public class InterfacesOperationsConverterTest { Map<String, Object> resultMap = interfacesOperationsConverter.getInterfacesMap(service, null, service.getInterfaces(), null, false, false); - Assert.assertTrue(MapUtils.isNotEmpty(resultMap) + assertTrue(MapUtils.isNotEmpty(resultMap) && resultMap.containsKey("NotLocal")); } } diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/model/ToscaInterfaceDefinitionTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/model/ToscaInterfaceDefinitionTest.java deleted file mode 100644 index b922d0d60d..0000000000 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/model/ToscaInterfaceDefinitionTest.java +++ /dev/null @@ -1,72 +0,0 @@ -/*- - * ============LICENSE_START======================================================= - * SDC - * ================================================================================ - * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved. - * ================================================================================ - * 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. - * ============LICENSE_END========================================================= - */ - -package org.openecomp.sdc.be.tosca.model; - -import org.junit.Test; - -import java.util.Map; - -public class ToscaInterfaceDefinitionTest { - - private ToscaInterfaceDefinition createTestSubject() { - return new ToscaInterfaceDefinition(); - } - - @Test - public void testGetType() throws Exception { - ToscaInterfaceDefinition testSubject; - String result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getType(); - } - - @Test - public void testSetType() throws Exception { - ToscaInterfaceDefinition testSubject; - String type = ""; - - // default test - testSubject = createTestSubject(); - testSubject.setType(type); - } - - @Test - public void testGetOperations() throws Exception { - ToscaInterfaceDefinition testSubject; - Map<String, Object> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getOperations(); - } - - @Test - public void testSetOperations() throws Exception { - ToscaInterfaceDefinition testSubject; - Map<String, Object> toscaOperations = null; - - // default test - testSubject = createTestSubject(); - testSubject.setOperations(toscaOperations); - } -} |