Incorrect interface type is populated in tosca for Service proxy for Local interface operations
Change-Id: If7933d6537a14567297e716f154c2a48f7f34797
Issue-ID: SDC-2423
Signed-off-by: Mojahidul Islam <mojahidul.islam@amdocs.com>
InterfaceDefinition storedInterfaceDefinition, Map<String, InterfaceDefinition> globalInterfaceTypes,
boolean isUpdate) {
- Either<Boolean, ResponseFormat> validateAllowedOperationCountOnLocalInterfaceType =
- validateAllowedOperationCountOnLocalInterfaceType(inputInterfaceDefinition, storedInterfaceDefinition,
- globalInterfaceTypes, isUpdate);
- if (validateAllowedOperationCountOnLocalInterfaceType.isRight()) {
- return validateAllowedOperationCountOnLocalInterfaceType;
- }
-
Either<Boolean, ResponseFormat> validateAllowedOperationsOnGlobalInterfaceType =
validateAllowedOperationsOnGlobalInterfaceType(inputInterfaceDefinition, globalInterfaceTypes);
if (validateAllowedOperationsOnGlobalInterfaceType.isRight()) {
public class InterfacesOperationsToscaUtil {
private static final String DERIVED_FROM_STANDARD_INTERFACE = "tosca.interfaces.node.lifecycle.Standard";
+ private static final String DERIVED_FROM_BASE_DEFAULT = "org.openecomp.interfaces.node.lifecycle.";
private static final String OPERATIONS_KEY = "operations";
private static final String DEFAULT = "default";
private static final String DEFAULTP = "defaultp";
public static final String SELF = "SELF";
+ private static final String LOCAL_INTERFACE_TYPE = "Local";
private InterfacesOperationsToscaUtil() {
}
Map<String, Object> operationsMap = (Map<String, Object>) interfacesAsMap.remove(OPERATIONS_KEY);
interfacesAsMap.putAll(operationsMap);
- toscaInterfaceTypes.put(interfaceDefinition.getType(), interfacesAsMap);
+ toscaInterfaceTypes.put(getInterfaceType(component, LOCAL_INTERFACE_TYPE), interfacesAsMap);
}
}
return MapUtils.isNotEmpty(toscaInterfaceTypes) ? toscaInterfaceTypes : null;
Map<String, Object> toscaInterfaceDefinitions = new HashMap<>();
for (InterfaceDefinition interfaceDefinition : interfaces.values()) {
ToscaInterfaceDefinition toscaInterfaceDefinition = new ToscaInterfaceDefinition();
- final String interfaceType = interfaceDefinition.getType();
+ String interfaceType;
+ if(componentInstance != null && LOCAL_INTERFACE_TYPE.equals(interfaceDefinition.getType())) {
+ interfaceType = DERIVED_FROM_BASE_DEFAULT + componentInstance.getSourceModelName();
+ } else {
+ interfaceType = getInterfaceType(component, interfaceDefinition.getType());
+ }
toscaInterfaceDefinition.setType(interfaceType);
final Map<String, OperationDataDefinition> operations = interfaceDefinition.getOperations();
Map<String, Object> toscaOperations = new HashMap<>();
return toscaInputValue;
}
+ private static String getInterfaceType(Component component, String interfaceType) {
+ if (LOCAL_INTERFACE_TYPE.equals(interfaceType)) {
+ return DERIVED_FROM_BASE_DEFAULT
+ + component.getComponentMetadataDefinition()
+ .getMetadataDataDefinition().getSystemName();
+ }
+
+ return interfaceType;
+ }
+
private static Map<String, Object> getObjectAsMap(Object obj) {
ObjectMapper objectMapper = new ObjectMapper();
if (obj instanceof ToscaInterfaceDefinition) {
component.getInterfaces().get(interfaceType1), Collections.emptyMap(), false).isRight());
}
- @Test
- public void shouldFailValidateAllowedOperationCountOnLocalInterfaceType() {
- InterfaceDefinition inputInterfaceDefinition =
- InterfaceOperationTestUtils.createMockInterface(interfaceType1
- , operationId, operationType1);
- Assert.assertTrue(interfaceOperationValidationUtilTest
- .validateInterfaceOperations(inputInterfaceDefinition, component,
- component.getInterfaces().get(interfaceType1),
- InterfaceOperationTestUtils.createMockInterfaceTypeMap(
- interfaceType2, operationType1), false).isRight());
- }
-
@Test
public void shouldFailValidateAllowedOperationsOnGlobalInterfaceType() {
InterfaceDefinition inputInterfaceDefinition =
import com.google.gson.Gson;
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 org.apache.commons.collections4.MapUtils;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
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;
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("interface.types.test_resource_name");
+ addedInterface.setType("Local");
addOperationsToInterface(component, addedInterface, 5, 3, true, false);
final String interfaceType = "normalizedComponentName-interface";
component.setInterfaces(new HashMap<>());
final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template);
Assert.assertFalse(toscaRepresentation.getMainYaml().contains("operations"));
- Assert.assertTrue(toscaRepresentation.getMainYaml().contains("interface.types.test_resource_name"));
+ 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("interface.types.test_service_name");
+ addedInterface.setType("Local");
addOperationsToInterface(component, addedInterface, 5, 3, true, false);
final String interfaceType = "normalizedServiceComponentName-interface";
component.setInterfaces(new HashMap<>());
final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template);
Assert.assertFalse(toscaRepresentation.getMainYaml().contains("operations"));
- Assert.assertTrue(toscaRepresentation.getMainYaml().contains("interface.types.test_service_name"));
+ Assert.assertTrue(toscaRepresentation.getMainYaml().contains("NodeTypeName"));
}
@Test
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.setToscaResourceName("com.some.service.or.other.serviceName");
-//
-// addOperationsToInterface(addedInterface, 3, 2, true);
-// final String interfaceType = "normalizedServiceComponentName-interface";
-// component.setInterfaces(new HashMap<>());
-// component.getInterfaces().put(interfaceType, addedInterface);
-// ToscaNodeType nodeType = new ToscaNodeType();
-// InterfacesOperationsToscaUtil.addInterfaceDefinitionElement(component, nodeType);
-//
-// ToscaExportHandler handler = new ToscaExportHandler();
-// ToscaTemplate template = new ToscaTemplate("testService");
-// Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
-// nodeTypes.put("test", nodeType);
-// template.setNode_types(nodeTypes);
-// final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template);
-//
-// Assert.assertFalse(toscaRepresentation.getMainYaml().contains("operations"));
-// Assert.assertTrue(toscaRepresentation.getMainYaml().contains("serviceName:"));
-// Assert.assertTrue(toscaRepresentation.getMainYaml().contains("inputs:"));
-// Assert.assertFalse(toscaRepresentation.getMainYaml().contains("defaultp"));
-// Assert.assertTrue(toscaRepresentation.getMainYaml().contains("has description"));
-// Assert.assertTrue(toscaRepresentation.getMainYaml().contains("naming_function_"));
-// Assert.assertTrue(toscaRepresentation.getMainYaml().contains("com.some.service.or.other.serviceName"));
-// }
-
@Test
public void addInterfaceDefinitionElement_noInputs() {
Component component = new Resource();
}
}
}
+
+ @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<String, Object> 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<String, Object> resultMap = InterfacesOperationsToscaUtil.getInterfacesMap(service, null,
+ service.getInterfaces(), null, false, false);
+
+ Assert.assertTrue(MapUtils.isNotEmpty(resultMap)
+ && resultMap.containsKey("NotLocal"));
+ }
}
//VSP Validation Operation
final String VSP_VALIDATION_CONFIGURATION = SDC_HTTP_METHOD + "://%s:%s/onboarding-api/v1.0/externaltesting/config";
+ final String GET_INSTANCE_TOSCA_ARTIFACTS = SDC_HTTP_METHOD
+ + "://%s:%s/sdc2/rest/v1/catalog/%s/%s/filteredDataByParams?include=toscaArtifacts";
}
import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
import org.openecomp.sdc.be.datatypes.elements.OperationOutputDefinition;
+import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
import org.openecomp.sdc.be.model.InputDefinition;
import org.openecomp.sdc.be.model.InterfaceDefinition;
import org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils;
import org.openecomp.sdc.ci.tests.utils.rest.InterfaceOperationsRestUtils;
import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
+import org.openecomp.sdc.ci.tests.utils.rest.ServiceRestUtils;
import org.testng.Assert;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
Assert.assertEquals((int) restResponse.getErrorCode(), BaseRestUtils.STATUS_CODE_SUCCESS);
}
+ @Test
+ public void testCreateOperationWithLocalInterfaceAndDownloadArtifact() throws Exception{
+ Either<Service, RestResponse> createDefaultServiceEither =
+ AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true);
+ if (createDefaultServiceEither.isRight()) {
+ fail("Error creating default service");
+ }
+ Service service = createDefaultServiceEither.left().value();
+ String serviceUniqueId = service.getUniqueId();
+ Operation operation = new Operation();
+ operation.setName("LocalOper");
+ operation.setWorkflowAssociationType("NONE");
+ Map<String, Object> interfaceOperationMap = buildInterfaceDefinitionMap(operation, "Local", null, null);
+
+ RestResponse restResponse = InterfaceOperationsRestUtils.addInterfaceOperations(service, interfaceOperationMap,
+ user);
+
+ Integer responseCode = restResponse.getErrorCode();
+ Integer expectedCode = 200;
+ Assert.assertEquals(responseCode, expectedCode);
+
+ service = ResponseParser.convertServiceResponseToJavaObject(
+ ServiceRestUtils.getServiceToscaArtifacts(service.getUniqueId()).getResponse());
+ service.setUniqueId(serviceUniqueId);
+ service.setComponentType(ComponentTypeEnum.SERVICE);
+ service.setLastUpdaterUserId(user.getUserId());
+ Either<String, RestResponse> responseEither = AtomicOperationUtils
+ .getComponenetArtifactPayload(service, "assettoscacsar");
+
+ Assert.assertTrue(responseEither.isLeft());
+ }
+
@Test
public void addInterfaceOperationsOnService() throws Exception {
RestResponse restResponse = InterfaceOperationsRestUtils
return getServiceFromUrl(url, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), false);
}
+ public static RestResponse getServiceToscaArtifacts(String serviceId) throws IOException {
+
+ Config config = Utils.getConfig();
+ String url = String.format(Urls.GET_INSTANCE_TOSCA_ARTIFACTS, config.getCatalogBeHost(),
+ config.getCatalogBePort(), "services", serviceId);
+ return getServiceFromUrl(url, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), false);
+ }
+
public static RestResponse getService(ServiceReqDetails serviceReqDetails, User sdncModifierDetails)
throws IOException {
<include name="getInterfaceOperationsFromService"/>
<include name="updateInterfaceOperationsOnService"/>
<include name="deleteInterfaceOperationsFromService"/>
+ <include name="testCreateOperationWithLocalInterfaceAndDownloadArtifact"/>
</methods>
</class>
</classes>