diff options
35 files changed, 1573 insertions, 93 deletions
diff --git a/catalog-be/src/main/docker/backend/chef-repo/cookbooks/sdc-catalog-be/files/default/error-configuration.yaml b/catalog-be/src/main/docker/backend/chef-repo/cookbooks/sdc-catalog-be/files/default/error-configuration.yaml index 3e1b16d82f..b49c111c79 100644 --- a/catalog-be/src/main/docker/backend/chef-repo/cookbooks/sdc-catalog-be/files/default/error-configuration.yaml +++ b/catalog-be/src/main/docker/backend/chef-repo/cookbooks/sdc-catalog-be/files/default/error-configuration.yaml @@ -2437,3 +2437,31 @@ errors: message: '%1 is not yet supported', messageId: "SVC4139" } + #---------SVC4140------------------------------ + # %1 - Component uid + COMPONENT_FIND_ERROR: { + code: 500, + message: "An unexpected error occurred while retrieving the component '%1'.", + messageId: "SVC4140" + } + #---------SVC4141------------------------------ + # %1 - Component uid + COMPONENT_CAPABILITIES_FIND_ERROR: { + code: 500, + message: "An unexpected error occurred while retrieving the component '%1' capabilities.", + messageId: "SVC4141" + } + #---------SVC4142------------------------------ + # %1 - Component uid or name + COMPONENT_NOT_FOUND: { + code: 404, + message: "Component '%1' was not found.", + messageId: "SVC4142" + } + #---------SVC4143------------------------------ + # %1 - Capability name + COMPONENT_INSTANCE_CAPABILITY_UPDATE_ERROR: { + code: 500, + message: "An unexpected error occurred while updating the capability '%1'.", + messageId: "SVC4143" + }
\ No newline at end of file diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ComponentInstanceBusinessLogic.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ComponentInstanceBusinessLogic.java index b602072354..b8fabc307f 100644 --- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ComponentInstanceBusinessLogic.java +++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ComponentInstanceBusinessLogic.java @@ -74,6 +74,7 @@ import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum; import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; import org.openecomp.sdc.be.datatypes.tosca.ToscaGetFunctionType; +import org.openecomp.sdc.be.exception.BusinessException; import org.openecomp.sdc.be.impl.ComponentsUtils; import org.openecomp.sdc.be.impl.ForwardingPathUtils; import org.openecomp.sdc.be.impl.ServiceFilterUtils; @@ -108,6 +109,7 @@ import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArtifactsOperations; import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ForwardingPathOperation; import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation; import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeFilterOperation; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeTemplateOperation; import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade; import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter; import org.openecomp.sdc.be.model.operations.StorageException; @@ -130,6 +132,8 @@ import org.openecomp.sdc.common.api.Constants; import org.openecomp.sdc.common.datastructure.Wrapper; import org.openecomp.sdc.common.jsongraph.util.CommonUtility; import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum; +import org.openecomp.sdc.common.log.elements.ErrorLogOptionalData; +import org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode; import org.openecomp.sdc.common.log.wrappers.Logger; import org.openecomp.sdc.common.util.ValidationUtils; import org.openecomp.sdc.exception.ResponseFormat; @@ -153,6 +157,8 @@ public class ComponentInstanceBusinessLogic extends BaseBusinessLogic { private static final String FAILED_TO_COPY_COMP_INSTANCE_TO_CANVAS = "Failed to copy the component instance to the canvas"; private static final String COPY_COMPONENT_INSTANCE_OK = "Copy component instance OK"; private static final String CANNOT_ATTACH_RESOURCE_INSTANCES_TO_CONTAINER_RESOURCE_OF_TYPE = "Cannot attach resource instances to container resource of type {}"; + private static final String FAILED_TO_UPDATE_COMPONENT_INSTANCE_CAPABILITY = "Failed to update component instance capability on instance {} in " + + "container {}"; private static final String SERVICE_PROXY = "serviceProxy"; private static final String ASSOCIATE_RI_TO_RI = "associateRIToRI"; private ComponentInstanceOperation componentInstanceOperation; @@ -3238,6 +3244,69 @@ public class ComponentInstanceBusinessLogic extends BaseBusinessLogic { } } + public Either<CapabilityDefinition, ResponseFormat> updateInstanceCapability(final ComponentTypeEnum containerComponentType, + final String containerComponentId, + final String componentInstanceUniqueId, + final CapabilityDefinition capabilityDefinition, + final String userId) { + if (containerComponentType == null) { + BeEcompErrorManager.getInstance().logInvalidInputError("updateInstanceCapability", INVALID_COMPONENT_TYPE, ErrorSeverity.INFO); + return Either.right(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED)); + } + validateUserExists(userId); + final Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaFullElement(containerComponentId); + if (getResourceResult.isRight()) { + log.debug(FAILED_TO_RETRIEVE_COMPONENT_COMPONENT_ID, containerComponentId); + return Either.right(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_NOT_FOUND, containerComponentId)); + } + final Component containerComponent = getResourceResult.left().value(); + if (!ComponentValidationUtils.canWorkOnComponent(containerComponent, userId)) { + log.info("Restricted operation for user: {} on component {}", userId, containerComponentId); + return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION)); + } + final Either<ComponentInstance, StorageOperationStatus> resourceInstanceStatus = + getResourceInstanceById(containerComponent, componentInstanceUniqueId); + if (resourceInstanceStatus.isRight()) { + return Either.right(componentsUtils + .getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceUniqueId, containerComponentId)); + } + // lock resource + final StorageOperationStatus lockStatus = graphLockOperation.lockComponent(containerComponentId, containerComponentType.getNodeType()); + if (lockStatus != StorageOperationStatus.OK) { + log.debug("Failed to lock component {}", containerComponentId); + return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(lockStatus))); + } + var success = false; + try { + final CapabilityDataDefinition updatedCapabilityDefinition = toscaOperationFacade + .updateComponentInstanceCapability(containerComponentId, componentInstanceUniqueId, capabilityDefinition); + final Either<Component, StorageOperationStatus> updateContainerEither = toscaOperationFacade + .updateComponentInstanceMetadataOfTopologyTemplate(containerComponent); + if (updateContainerEither.isRight()) { + var actionStatus = componentsUtils.convertFromStorageResponse(updateContainerEither.right().value(), containerComponentType); + return Either.right(componentsUtils.getResponseFormat(actionStatus)); + } + success = true; + return Either.left(new CapabilityDefinition(updatedCapabilityDefinition)); + } catch (final BusinessException e) { + log.error(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR, NodeTemplateOperation.class.getName(), (ErrorLogOptionalData) null, + FAILED_TO_UPDATE_COMPONENT_INSTANCE_CAPABILITY, componentInstanceUniqueId, containerComponentId); + throw e; + } catch (final Exception e) { + log.error(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR, NodeTemplateOperation.class.getName(), (ErrorLogOptionalData) null, + FAILED_TO_UPDATE_COMPONENT_INSTANCE_CAPABILITY, componentInstanceUniqueId, containerComponentId); + throw new ByResponseFormatComponentException(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR)); + } finally { + if (success) { + janusGraphDao.commit(); + } else { + janusGraphDao.rollback(); + } + // unlock resource + graphLockOperation.unlockComponent(containerComponentId, containerComponentType.getNodeType()); + } + } + public Either<List<ComponentInstanceProperty>, ResponseFormat> updateInstanceCapabilityProperties(ComponentTypeEnum componentTypeEnum, String containerComponentId, String componentInstanceUniqueId, diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/exceptions/ComponentException.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/exceptions/ComponentException.java index 351d279875..7410e888f0 100644 --- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/exceptions/ComponentException.java +++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/exceptions/ComponentException.java @@ -22,10 +22,11 @@ package org.openecomp.sdc.be.components.impl.exceptions; import javax.annotation.Nullable; import org.openecomp.sdc.be.components.impl.ResponseFormatManager; import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.exception.BusinessException; import org.openecomp.sdc.be.model.Resource; import org.openecomp.sdc.exception.ResponseFormat; -public class ComponentException extends RuntimeException { +public class ComponentException extends BusinessException { /** * This class will be initialized either by action status and params or by ResponseFormat diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/ComponentInstanceCapabilityServlet.java b/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/ComponentInstanceCapabilityServlet.java new file mode 100644 index 0000000000..f83f83df2b --- /dev/null +++ b/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/ComponentInstanceCapabilityServlet.java @@ -0,0 +1,144 @@ +/* + * ============LICENSE_START======================================================= + * Copyright (C) 2021 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.servlets; + +import com.jcabi.aspects.Loggable; +import fj.data.Either; +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.media.ArraySchema; +import io.swagger.v3.oas.annotations.media.Content; +import io.swagger.v3.oas.annotations.media.Schema; +import io.swagger.v3.oas.annotations.responses.ApiResponse; +import io.swagger.v3.oas.annotations.servers.Server; +import io.swagger.v3.oas.annotations.tags.Tag; +import javax.servlet.http.HttpServletRequest; +import javax.validation.Valid; +import javax.validation.constraints.NotNull; +import javax.ws.rs.Consumes; +import javax.ws.rs.HeaderParam; +import javax.ws.rs.PUT; +import javax.ws.rs.Path; +import javax.ws.rs.PathParam; +import javax.ws.rs.Produces; +import javax.ws.rs.core.Context; +import javax.ws.rs.core.MediaType; +import javax.ws.rs.core.Response; +import org.openecomp.sdc.be.components.impl.ComponentInstanceBusinessLogic; +import org.openecomp.sdc.be.components.impl.ResponseFormatManager; +import org.openecomp.sdc.be.components.impl.aaf.AafPermission; +import org.openecomp.sdc.be.components.impl.aaf.PermissionAllowed; +import org.openecomp.sdc.be.config.BeEcompErrorManager; +import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; +import org.openecomp.sdc.be.exception.BusinessException; +import org.openecomp.sdc.be.model.CapabilityDefinition; +import org.openecomp.sdc.be.servlets.builder.ServletResponseBuilder; +import org.openecomp.sdc.be.ui.mapper.CapabilityMapper; +import org.openecomp.sdc.be.ui.model.ComponentInstanceCapabilityUpdateModel; +import org.openecomp.sdc.common.api.Constants; +import org.openecomp.sdc.common.log.elements.LoggerSupportability; +import org.openecomp.sdc.common.log.enums.LoggerSupportabilityActions; +import org.openecomp.sdc.common.log.enums.StatusCode; +import org.openecomp.sdc.common.log.wrappers.Logger; +import org.openecomp.sdc.exception.ResponseFormat; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestBody; + +/** + * Handles component instance capabilities operations + */ +@Loggable(prepend = true, value = Loggable.DEBUG, trim = false) +@Path("/v1/catalog") +@Tag(name = "SDCE-2 APIs") +@Server(url = "/sdc2/rest") +@Controller +public class ComponentInstanceCapabilityServlet { + + private static final Logger LOGGER = Logger.getLogger(ComponentInstanceCapabilityServlet.class); + private static final LoggerSupportability LOGGER_SUPPORTABILITY = LoggerSupportability.getLogger(ComponentInstanceCapabilityServlet.class); + + private final ResponseFormatManager responseFormatManager; + private final ComponentInstanceBusinessLogic componentInstanceBusinessLogic; + private final CapabilityMapper capabilityMapper; + private final ServletResponseBuilder servletResponseBuilder; + + public ComponentInstanceCapabilityServlet(final ComponentInstanceBusinessLogic componentInstanceBusinessLogic, + final CapabilityMapper capabilityMapper, final ServletResponseBuilder servletResponseBuilder) { + this.capabilityMapper = capabilityMapper; + this.servletResponseBuilder = servletResponseBuilder; + this.responseFormatManager = ResponseFormatManager.getInstance(); + this.componentInstanceBusinessLogic = componentInstanceBusinessLogic; + } + + @PUT + @Path("/{containerComponentType}/{containerComponentId}/componentInstances/{componentInstanceUniqueId}/capability/") + @Consumes(MediaType.APPLICATION_JSON) + @Produces(MediaType.APPLICATION_JSON) + @Operation(description = "Update Component Instance Capability", method = "PUT", summary = "Returns updated Component Instance Capability", + responses = { + @ApiResponse(content = @Content(array = @ArraySchema(schema = @Schema(implementation = Response.class)))), + @ApiResponse(responseCode = "200", description = "Resource instance capability successfully updated"), + @ApiResponse(responseCode = "403", description = "Restricted operation"), + @ApiResponse(responseCode = "400", description = "Invalid content / Missing content"), + @ApiResponse(responseCode = "404", description = "Component/Component Instance/Capability not found")}) + @PermissionAllowed(AafPermission.PermNames.INTERNAL_ALL_VALUE) + public Response updateInstanceRequirement(@PathParam("containerComponentType") final String containerComponentType, + @PathParam("containerComponentId") final String containerComponentId, + @PathParam("componentInstanceUniqueId") final String componentInstanceUniqueId, + @Parameter(description = "Component instance capability to update", required = true) + @Valid @RequestBody @NotNull final ComponentInstanceCapabilityUpdateModel capabilityUpdateModel, + @Context final HttpServletRequest request, + @HeaderParam(value = Constants.USER_ID_HEADER) final String userId) { + if (LOGGER.isDebugEnabled()) { + final var url = request.getMethod() + " " + request.getRequestURI(); + LOGGER.debug("Start handle request of {}", url); + } + try { + var componentTypeEnum = ComponentTypeEnum.findByParamName(containerComponentType); + if (componentTypeEnum == null) { + LOGGER.debug("Unsupported component type {}", containerComponentType); + return servletResponseBuilder + .buildErrorResponse(responseFormatManager.getResponseFormat(ActionStatus.UNSUPPORTED_ERROR, containerComponentType)); + } + final var capabilityDefinition = capabilityMapper.mapToCapabilityDefinition(capabilityUpdateModel); + LOGGER_SUPPORTABILITY.log(LoggerSupportabilityActions.UPDATE_INSTANCE_CAPABILITY, StatusCode.STARTED, + "Starting to update capability '{}' in component instance '{}' by '{}'", + capabilityDefinition.getName(), componentInstanceUniqueId, userId); + final Either<CapabilityDefinition, ResponseFormat> response = componentInstanceBusinessLogic + .updateInstanceCapability(componentTypeEnum, containerComponentId, componentInstanceUniqueId, capabilityDefinition, userId); + if (response.isRight()) { + return servletResponseBuilder.buildErrorResponse(response.right().value()); + } + return servletResponseBuilder.buildOkResponse(responseFormatManager.getResponseFormat(ActionStatus.OK), response.left().value()); + } catch (final BusinessException e) { + //leave to the handlers deal with it + throw e; + } catch (final Exception e) { + var errorMsg = String + .format("Unexpected error while updating component '%s' of type '%s' instance '%s'. Payload '%s'", + containerComponentId, containerComponentType, componentInstanceUniqueId, capabilityUpdateModel); + BeEcompErrorManager.getInstance().logBeRestApiGeneralError(errorMsg); + LOGGER.debug(errorMsg, e); + return servletResponseBuilder.buildErrorResponse(responseFormatManager.getResponseFormat(ActionStatus.GENERAL_ERROR)); + } + } + +} diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/ComponentInstanceServlet.java b/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/ComponentInstanceServlet.java index 7816d3d0be..d44c26ee6a 100644 --- a/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/ComponentInstanceServlet.java +++ b/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/ComponentInstanceServlet.java @@ -1046,7 +1046,7 @@ public class ComponentInstanceServlet extends AbstractValidationsServlet { try { log.debug(START_HANDLE_REQUEST_OF, url); ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.findByParamName(containerComponentType); - if (componentInstanceBusinessLogic == null) { + if (componentTypeEnum == null) { log.debug(UNSUPPORTED_COMPONENT_TYPE, containerComponentType); return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.UNSUPPORTED_ERROR, containerComponentType)); } diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/builder/ServletResponseBuilder.java b/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/builder/ServletResponseBuilder.java new file mode 100644 index 0000000000..a36ccf5133 --- /dev/null +++ b/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/builder/ServletResponseBuilder.java @@ -0,0 +1,72 @@ +/* + * ============LICENSE_START======================================================= + * Copyright (C) 2021 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.servlets.builder; + +import com.google.gson.Gson; +import com.google.gson.GsonBuilder; +import java.util.Map; +import java.util.Map.Entry; +import javax.ws.rs.core.Response; +import org.apache.commons.collections.MapUtils; +import org.openecomp.sdc.common.log.wrappers.Logger; +import org.openecomp.sdc.exception.ResponseFormat; +import org.springframework.stereotype.Service; + +@Service +public class ServletResponseBuilder { + + private final Gson gson; + + public ServletResponseBuilder() { + gson = new GsonBuilder().setPrettyPrinting().create(); + } + + private static final Logger log = Logger.getLogger(ServletResponseBuilder.class); + + public Response buildErrorResponse(final ResponseFormat requestErrorWrapper) { + return Response.status(requestErrorWrapper.getStatus()).entity(gson.toJson(requestErrorWrapper.getRequestError())).build(); + } + + public Response buildOkResponse(final ResponseFormat errorResponseWrapper, final Object entity) { + return buildOkResponse(errorResponseWrapper, entity, null); + } + + public Response buildOkResponse(final ResponseFormat errorResponseWrapper, final Object entity, + final Map<String, String> additionalHeaders) { + final int status = errorResponseWrapper.getStatus(); + var responseBuilder = Response.status(status); + if (entity != null) { + if (log.isTraceEnabled()) { + log.trace("returned entity is {}", entity.toString()); + } + responseBuilder = responseBuilder.entity(entity); + } + if (MapUtils.isNotEmpty(additionalHeaders)) { + for (final Entry<String, String> additionalHeader : additionalHeaders.entrySet()) { + final String headerName = additionalHeader.getKey(); + final String headerValue = additionalHeader.getValue(); + log.trace("Adding header {} with value {} to the response", headerName, headerValue); + responseBuilder = responseBuilder.header(headerName, headerValue); + } + } + return responseBuilder.build(); + } + +} diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/exception/OperationExceptionMapper.java b/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/exception/OperationExceptionMapper.java new file mode 100644 index 0000000000..7c25f8aef8 --- /dev/null +++ b/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/exception/OperationExceptionMapper.java @@ -0,0 +1,50 @@ +/* + * ============LICENSE_START======================================================= + * Copyright (C) 2021 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.servlets.exception; + +import javax.ws.rs.core.Response; +import javax.ws.rs.ext.ExceptionMapper; +import javax.ws.rs.ext.Provider; +import org.openecomp.sdc.be.components.impl.ResponseFormatManager; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.OperationException; +import org.openecomp.sdc.be.servlets.builder.ServletResponseBuilder; +import org.openecomp.sdc.common.log.wrappers.Logger; +import org.springframework.stereotype.Component; + +@Component +@Provider +public class OperationExceptionMapper implements ExceptionMapper<OperationException> { + + private final ServletResponseBuilder servletResponseBuilder; + private final ResponseFormatManager responseFormatManager; + + private static final Logger log = Logger.getLogger(OperationExceptionMapper.class); + + public OperationExceptionMapper(final ServletResponseBuilder servletResponseBuilder) { + this.servletResponseBuilder = servletResponseBuilder; + this.responseFormatManager = ResponseFormatManager.getInstance(); + } + + @Override + public Response toResponse(final OperationException exception) { + log.debug("Handling OperationException response", exception); + return servletResponseBuilder.buildErrorResponse(responseFormatManager.getResponseFormat(exception.getActionStatus(), exception.getParams())); + } +} diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/CapabilityRequirementConverter.java b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/CapabilityRequirementConverter.java index ac4f8bf6c8..88f3666305 100644 --- a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/CapabilityRequirementConverter.java +++ b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/CapabilityRequirementConverter.java @@ -323,9 +323,11 @@ public class CapabilityRequirementConverter { Map<String, String[]> toscaCapabilities = new HashMap<>(); Either<Map<String, String[]>, ToscaError> result = null; for (Map.Entry<String, List<CapabilityDefinition>> entry : capabilities.entrySet()) { - Optional<CapabilityDefinition> failedToAddRequirement = entry.getValue().stream().filter( - c -> !addEntry(componentsCache, toscaCapabilities, component, new SubstitutionEntry(c.getName(), c.getParentName(), ""), - c.getPreviousName(), c.getOwnerId(), c.getPath())).findAny(); + Optional<CapabilityDefinition> failedToAddRequirement = entry.getValue().stream() + .filter(CapabilityDataDefinition::isExternal) + .filter( c -> !addEntry(componentsCache, toscaCapabilities, component, new SubstitutionEntry(c.getName(), c.getParentName(), "") + , c.getPreviousName(), c.getOwnerId(), c.getPath())) + .findAny(); if (failedToAddRequirement.isPresent()) { logger.debug("Failed to convert capability {} for substitution mappings section of a tosca template of the component {}. ", failedToAddRequirement.get().getName(), component.getName()); diff --git a/catalog-be/src/main/java/org/openecomp/sdc/config/CatalogBESpringConfig.java b/catalog-be/src/main/java/org/openecomp/sdc/config/CatalogBESpringConfig.java index 570cabee5f..0c78b1fdef 100644 --- a/catalog-be/src/main/java/org/openecomp/sdc/config/CatalogBESpringConfig.java +++ b/catalog-be/src/main/java/org/openecomp/sdc/config/CatalogBESpringConfig.java @@ -65,7 +65,8 @@ import org.springframework.core.annotation.Order; "org.openecomp.sdc.be.servlets", "org.openecomp.sdc.be.filters", "org.openecomp.sdc.be.plugins", - "org.openecomp.sdc.be.togglz"}) + "org.openecomp.sdc.be.togglz", + "org.openecomp.sdc.be.ui.mapper"}) // @formatter:on public class CatalogBESpringConfig { diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ComponentInstanceBusinessLogicTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ComponentInstanceBusinessLogicTest.java index 07fff19f0b..5c8b6ce6d2 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ComponentInstanceBusinessLogicTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ComponentInstanceBusinessLogicTest.java @@ -23,10 +23,12 @@ package org.openecomp.sdc.be.components.impl; import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertSame; import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.DynamicTest.dynamicTest; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anySet; @@ -79,12 +81,12 @@ import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition; import org.openecomp.sdc.be.datatypes.elements.GetPolicyValueDataDefinition; import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition; import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition; import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum; import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; +import org.openecomp.sdc.be.exception.BusinessException; import org.openecomp.sdc.be.impl.ComponentsUtils; import org.openecomp.sdc.be.model.ArtifactDefinition; import org.openecomp.sdc.be.model.CapabilityDefinition; @@ -111,6 +113,7 @@ import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache; import org.openecomp.sdc.be.model.jsonjanusgraph.config.ContainerInstanceTypesData; import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ForwardingPathOperation; import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.OperationException; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation; import org.openecomp.sdc.be.model.operations.impl.PropertyOperation; @@ -201,7 +204,7 @@ class ComponentInstanceBusinessLogicTest { @BeforeEach void init() { - MockitoAnnotations.initMocks(this); + MockitoAnnotations.openMocks(this); stubMethods(); createComponents(); } @@ -1950,6 +1953,216 @@ class ComponentInstanceBusinessLogicTest { } + @Test + void updateInstanceCapabilitySuccessTest() { + var containerComponentId = "containerComponentId"; + var componentInstanceUniqueId = "componentInstanceUniqueId"; + var capabilityDefinition = new CapabilityDefinition(); + capabilityDefinition.setUniqueId("uniqueId"); + + final Component component = new Service(); + component.setUniqueId(containerComponentId); + component.setLastUpdaterUserId(USER_ID); + component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); + + var componentInstance = new ComponentInstance(); + componentInstance.setUniqueId(componentInstanceUniqueId); + component.setComponentInstances(Collections.singletonList(componentInstance)); + + when(toscaOperationFacade.getToscaFullElement(containerComponentId)) + .thenReturn(Either.left(component)); + when(toscaOperationFacade.updateComponentInstanceCapability(containerComponentId, componentInstanceUniqueId, capabilityDefinition)) + .thenReturn(capabilityDefinition); + when(toscaOperationFacade.updateComponentInstanceMetadataOfTopologyTemplate(component)) + .thenReturn(Either.left(component)); + when(graphLockOperation.lockComponent(containerComponentId, NodeTypeEnum.Service)) + .thenReturn(StorageOperationStatus.OK); + + final Either<CapabilityDefinition, ResponseFormat> resultEither = componentInstanceBusinessLogic + .updateInstanceCapability(ComponentTypeEnum.SERVICE, containerComponentId, componentInstanceUniqueId, capabilityDefinition, USER_ID); + assertTrue(resultEither.isLeft()); + final CapabilityDefinition actualCapabilityDefinition = resultEither.left().value(); + assertNotEquals(capabilityDefinition, actualCapabilityDefinition); + assertEquals(capabilityDefinition.getUniqueId(), actualCapabilityDefinition.getUniqueId()); + } + + @Test + void updateInstanceCapabilityNoContainerComponentTypeTest() { + var responseFormat = new ResponseFormat(); + when(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED)).thenReturn(responseFormat); + final Either<CapabilityDefinition, ResponseFormat> resultEither = componentInstanceBusinessLogic + .updateInstanceCapability(null, "containerComponentId", "componentInstanceUniqueId", new CapabilityDefinition(), USER_ID); + assertTrue(resultEither.isRight(), "Either return should be right"); + final ResponseFormat actualResponseFormat = resultEither.right().value(); + assertEquals(responseFormat, actualResponseFormat); + } + + @Test + void updateInstanceCapabilityContainerComponentNotFoundTest() { + var containerComponentId = "containerComponentId"; + when(toscaOperationFacade.getToscaFullElement(containerComponentId)).thenReturn(Either.right(null)); + var responseFormat = new ResponseFormat(); + when(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_NOT_FOUND, containerComponentId)).thenReturn(responseFormat); + final Either<CapabilityDefinition, ResponseFormat> resultEither = componentInstanceBusinessLogic + .updateInstanceCapability(ComponentTypeEnum.SERVICE, "containerComponentId", "componentInstanceUniqueId", new CapabilityDefinition(), USER_ID); + assertTrue(resultEither.isRight(), "Either return should be right"); + final ResponseFormat actualResponseFormat = resultEither.right().value(); + assertEquals(responseFormat, actualResponseFormat); + } + + @Test + void updateInstanceCapabilityCannotWorkOnComponentTest() { + var containerComponentId = "containerComponentId"; + var componentInstanceUniqueId = "componentInstanceUniqueId"; + + final Component component = new Service(); + component.setUniqueId(containerComponentId); + component.setLastUpdaterUserId("anotherUse"); + component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); + + var expectedResponseFormat = new ResponseFormat(); + + when(toscaOperationFacade.getToscaFullElement(containerComponentId)) + .thenReturn(Either.left(component)); + when(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION)) + .thenReturn(expectedResponseFormat); + + final Either<CapabilityDefinition, ResponseFormat> resultEither = componentInstanceBusinessLogic + .updateInstanceCapability(ComponentTypeEnum.SERVICE, containerComponentId, componentInstanceUniqueId, new CapabilityDefinition(), USER_ID); + assertTrue(resultEither.isRight(), "Either return should be right"); + final ResponseFormat actualResponseFormat = resultEither.right().value(); + assertEquals(expectedResponseFormat, actualResponseFormat); + } + + @Test + void updateInstanceCapabilityResourceInstanceNotFoundTest() { + var containerComponentId = "containerComponentId"; + var componentInstanceUniqueId = "componentInstanceUniqueId"; + + final Component component = new Service(); + component.setUniqueId(containerComponentId); + component.setLastUpdaterUserId(USER_ID); + component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); + + var expectedResponseFormat = new ResponseFormat(); + + when(toscaOperationFacade.getToscaFullElement(containerComponentId)) + .thenReturn(Either.left(component)); + when(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceUniqueId, containerComponentId)) + .thenReturn(expectedResponseFormat); + + final Either<CapabilityDefinition, ResponseFormat> resultEither = componentInstanceBusinessLogic + .updateInstanceCapability(ComponentTypeEnum.SERVICE, containerComponentId, componentInstanceUniqueId, new CapabilityDefinition(), USER_ID); + assertTrue(resultEither.isRight(), "Either return should be right"); + final ResponseFormat actualResponseFormat = resultEither.right().value(); + assertEquals(expectedResponseFormat, actualResponseFormat); + } + + @Test + void updateInstanceCapabilityUpdateMetadataFailTest() { + var containerComponentId = "containerComponentId"; + var componentInstanceUniqueId = "componentInstanceUniqueId"; + var capabilityDefinition = new CapabilityDefinition(); + capabilityDefinition.setUniqueId("uniqueId"); + + final Component component = new Service(); + component.setUniqueId(containerComponentId); + component.setLastUpdaterUserId(USER_ID); + component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); + + var componentInstance = new ComponentInstance(); + componentInstance.setUniqueId(componentInstanceUniqueId); + component.setComponentInstances(Collections.singletonList(componentInstance)); + + var expectedResponseFormat = new ResponseFormat(); + + when(toscaOperationFacade.getToscaFullElement(containerComponentId)) + .thenReturn(Either.left(component)); + when(graphLockOperation.lockComponent(containerComponentId, NodeTypeEnum.Service)) + .thenReturn(StorageOperationStatus.OK); + when(toscaOperationFacade.updateComponentInstanceCapability(containerComponentId, componentInstanceUniqueId, capabilityDefinition)) + .thenReturn(capabilityDefinition); + when(toscaOperationFacade.updateComponentInstanceMetadataOfTopologyTemplate(component)) + .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR)); + when(componentsUtils.convertFromStorageResponse(StorageOperationStatus.GENERAL_ERROR, ComponentTypeEnum.SERVICE)) + .thenReturn(ActionStatus.GENERAL_ERROR); + when(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR)) + .thenReturn(expectedResponseFormat); + + final Either<CapabilityDefinition, ResponseFormat> resultEither = componentInstanceBusinessLogic + .updateInstanceCapability(ComponentTypeEnum.SERVICE, containerComponentId, componentInstanceUniqueId, capabilityDefinition, USER_ID); + assertTrue(resultEither.isRight(), "Either return should be right"); + final ResponseFormat actualResponseFormat = resultEither.right().value(); + assertEquals(expectedResponseFormat, actualResponseFormat); + } + + @Test + void updateInstanceCapabilityBusinessExceptionHandlingTest() { + var containerComponentId = "containerComponentId"; + var componentInstanceUniqueId = "componentInstanceUniqueId"; + var capabilityDefinition = new CapabilityDefinition(); + capabilityDefinition.setUniqueId("uniqueId"); + + final Component component = new Service(); + component.setUniqueId(containerComponentId); + component.setLastUpdaterUserId(USER_ID); + component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); + + var componentInstance = new ComponentInstance(); + componentInstance.setUniqueId(componentInstanceUniqueId); + component.setComponentInstances(Collections.singletonList(componentInstance)); + + + when(toscaOperationFacade.getToscaFullElement(containerComponentId)) + .thenReturn(Either.left(component)); + when(graphLockOperation.lockComponent(containerComponentId, NodeTypeEnum.Service)) + .thenReturn(StorageOperationStatus.OK); + when(toscaOperationFacade.updateComponentInstanceCapability(containerComponentId, componentInstanceUniqueId, capabilityDefinition)) + .thenThrow(new OperationException(ActionStatus.GENERAL_ERROR)); + + final BusinessException businessException = assertThrows(BusinessException.class, () -> { + componentInstanceBusinessLogic + .updateInstanceCapability(ComponentTypeEnum.SERVICE, containerComponentId, componentInstanceUniqueId, capabilityDefinition, USER_ID); + }); + assertTrue(businessException instanceof OperationException); + assertEquals(ActionStatus.GENERAL_ERROR, ((OperationException) businessException).getActionStatus()); + } + + @Test + void updateInstanceCapabilityUnknownExceptionHandlingTest() { + var containerComponentId = "containerComponentId"; + var componentInstanceUniqueId = "componentInstanceUniqueId"; + var capabilityDefinition = new CapabilityDefinition(); + capabilityDefinition.setUniqueId("uniqueId"); + + final Component component = new Service(); + component.setUniqueId(containerComponentId); + component.setLastUpdaterUserId(USER_ID); + component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); + + var componentInstance = new ComponentInstance(); + componentInstance.setUniqueId(componentInstanceUniqueId); + component.setComponentInstances(Collections.singletonList(componentInstance)); + + var expectedResponseFormat = new ResponseFormat(); + + when(toscaOperationFacade.getToscaFullElement(containerComponentId)) + .thenReturn(Either.left(component)); + when(graphLockOperation.lockComponent(containerComponentId, NodeTypeEnum.Service)) + .thenReturn(StorageOperationStatus.OK); + when(toscaOperationFacade.updateComponentInstanceCapability(containerComponentId, componentInstanceUniqueId, capabilityDefinition)) + .thenThrow(new RuntimeException()); + when(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR)) + .thenReturn(expectedResponseFormat); + + final Exception exception = assertThrows(BusinessException.class, () -> + componentInstanceBusinessLogic + .updateInstanceCapability(ComponentTypeEnum.SERVICE, containerComponentId, componentInstanceUniqueId, capabilityDefinition, USER_ID)); + assertTrue(exception instanceof ByResponseFormatComponentException); + final ByResponseFormatComponentException actualException = (ByResponseFormatComponentException) exception; + assertEquals(expectedResponseFormat, actualException.getResponseFormat()); + } + private ComponentInstance createServiceSubstitutionComponentInstance() { final ComponentInstance instanceToBeCreated = new ComponentInstance(); instanceToBeCreated.setName(COMPONENT_INSTANCE_NAME); diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/servlets/ComponentInstanceCapabilityServletTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/servlets/ComponentInstanceCapabilityServletTest.java new file mode 100644 index 0000000000..8155f22d65 --- /dev/null +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/servlets/ComponentInstanceCapabilityServletTest.java @@ -0,0 +1,240 @@ +/* + * ============LICENSE_START======================================================= + * Copyright (C) 2021 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.servlets; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; +import fj.data.Either; +import javax.ws.rs.client.Entity; +import javax.ws.rs.core.MediaType; +import javax.ws.rs.core.Response; +import org.glassfish.jersey.server.ResourceConfig; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.openecomp.sdc.be.components.impl.ComponentInstanceBusinessLogic; +import org.openecomp.sdc.be.config.ConfigurationManager; +import org.openecomp.sdc.be.config.ErrorInfo; +import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; +import org.openecomp.sdc.be.model.CapabilityDefinition; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.OperationException; +import org.openecomp.sdc.be.servlets.builder.ServletResponseBuilder; +import org.openecomp.sdc.be.servlets.exception.OperationExceptionMapper; +import org.openecomp.sdc.be.ui.mapper.CapabilityMapper; +import org.openecomp.sdc.be.ui.model.ComponentInstanceCapabilityUpdateModel; +import org.openecomp.sdc.common.api.ConfigurationSource; +import org.openecomp.sdc.common.api.Constants; +import org.openecomp.sdc.common.impl.ExternalConfiguration; +import org.openecomp.sdc.common.impl.FSConfigurationSource; +import org.openecomp.sdc.exception.ResponseFormat; +import org.openecomp.sdc.exception.ServiceException; + +class ComponentInstanceCapabilityServletTest extends JerseySpringBaseTest { + + private static final String UPDATE_INSTANCE_REQUIREMENT_PATH_FORMAT = "/v1/catalog/%s/%s/componentInstances/%s/capability"; + private static ConfigurationManager configurationManager; + + private final String componentId = "componentId"; + private final String componentInstanceId = "componentInstanceId"; + private final String userId = "userId"; + + private CapabilityMapper capabilityMapper; + private ComponentInstanceBusinessLogic componentInstanceBusinessLogicMock; + + @Override + protected ResourceConfig configure() { + componentInstanceBusinessLogicMock = mock(ComponentInstanceBusinessLogic.class); + capabilityMapper = new CapabilityMapper(); + var servletResponseBuilder = new ServletResponseBuilder(); + var componentInstanceCapabilityServlet = + new ComponentInstanceCapabilityServlet(componentInstanceBusinessLogicMock, capabilityMapper, servletResponseBuilder); + return super.configure().register(componentInstanceCapabilityServlet) + .register(new OperationExceptionMapper(servletResponseBuilder)); + } + + @BeforeAll + static void beforeAll() { + setupConfiguration(); + } + + private static void setupConfiguration() { + final ConfigurationSource configurationSource = + new FSConfigurationSource(ExternalConfiguration.getChangeListener(), "src/test/resources/config/catalog-be"); + configurationManager = new ConfigurationManager(configurationSource); + } + + //workaround for JerseyTest + Junit5 + @BeforeEach + void beforeEach() throws Exception { + super.setUp(); + } + + //workaround for JerseyTest + Junit5 + @AfterEach + void afterEach() throws Exception { + super.tearDown(); + } + + @Test + void updateInstanceRequirementSuccessTest() throws JsonProcessingException { + final var updateModel = createDefaultUpdateMode(); + var expectedCapabilityDefinition = capabilityMapper.mapToCapabilityDefinition(updateModel); + + when(componentInstanceBusinessLogicMock + .updateInstanceCapability(eq(ComponentTypeEnum.SERVICE), eq(componentId), eq(componentInstanceId), any(CapabilityDefinition.class), eq(userId))) + .thenReturn(Either.left(expectedCapabilityDefinition)); + final var url = + String.format(UPDATE_INSTANCE_REQUIREMENT_PATH_FORMAT, ComponentTypeEnum.SERVICE_PARAM_NAME, componentId, componentInstanceId); + + final Response response = target() + .path(url) + .request(MediaType.APPLICATION_JSON) + .header(Constants.USER_ID_HEADER, userId) + .put(Entity.entity(parseToJson(updateModel), MediaType.APPLICATION_JSON)); + var actualCapabilityDefinition = response.readEntity(CapabilityDefinition.class); + assertEquals(200, response.getStatus(), "The update status should be as expected"); + assertEquals(MediaType.valueOf(MediaType.APPLICATION_JSON), response.getMediaType(), "The content type should be application/json"); + assertCapabilityDefinition(actualCapabilityDefinition, expectedCapabilityDefinition); + } + + @Test + void updateInstanceRequirementFailTest() throws JsonProcessingException { + final var expectedResponseFormat = new ResponseFormat(404); + final var requestErrorWrapper = expectedResponseFormat.new RequestErrorWrapper(); + final var serviceException = new ServiceException("anErrorCode", "anErrorText", new String[2]); + requestErrorWrapper.setServiceException(serviceException); + expectedResponseFormat.setRequestError(requestErrorWrapper); + + when(componentInstanceBusinessLogicMock + .updateInstanceCapability(eq(ComponentTypeEnum.SERVICE), eq(componentId), eq(componentInstanceId), any(CapabilityDefinition.class), eq(userId))) + .thenReturn(Either.right(expectedResponseFormat)); + + final var url = + String.format(UPDATE_INSTANCE_REQUIREMENT_PATH_FORMAT, ComponentTypeEnum.SERVICE_PARAM_NAME, componentId, componentInstanceId); + final Response response = target() + .path(url) + .request(MediaType.APPLICATION_JSON) + .header(Constants.USER_ID_HEADER, userId) + .put(Entity.entity(parseToJson(createDefaultUpdateMode()), MediaType.APPLICATION_JSON)); + var actualResponseFormat = response.readEntity(ResponseFormat.class); + + assertEquals(expectedResponseFormat.getStatus(), response.getStatus(), "The update status should be as expected"); + assertNotNull(actualResponseFormat.getRequestError()); + assertNotNull(actualResponseFormat.getRequestError().getRequestError()); + assertEquals(expectedResponseFormat.getMessageId(), actualResponseFormat.getMessageId()); + assertEquals(expectedResponseFormat.getVariables().length, actualResponseFormat.getVariables().length); + } + + @Test + void updateInstanceRequirementKnownErrorTest() throws JsonProcessingException { + when(componentInstanceBusinessLogicMock + .updateInstanceCapability(eq(ComponentTypeEnum.SERVICE), eq(componentId), eq(componentInstanceId), any(CapabilityDefinition.class), eq(userId))) + .thenThrow(new OperationException(ActionStatus.COMPONENT_NOT_FOUND, componentId)); + final var url = + String.format(UPDATE_INSTANCE_REQUIREMENT_PATH_FORMAT, ComponentTypeEnum.SERVICE_PARAM_NAME, componentId, componentInstanceId); + final Response response = target() + .path(url) + .request(MediaType.APPLICATION_JSON) + .header(Constants.USER_ID_HEADER, userId) + .put(Entity.entity(parseToJson(createDefaultUpdateMode()), MediaType.APPLICATION_JSON)); + var responseFormat = response.readEntity(ResponseFormat.class); + + final ErrorInfo errorInfo = configurationManager.getErrorConfiguration().getErrorInfo(ActionStatus.COMPONENT_NOT_FOUND.name()); + assertNotNull(errorInfo); + assertEquals(errorInfo.getCode(), response.getStatus(), "The update status should be as expected"); + assertEquals(errorInfo.getMessageId(), responseFormat.getMessageId()); + assertEquals(errorInfo.getMessage(), responseFormat.getText()); + } + + @Test + void updateInstanceRequirementUnknownErrorTest() throws JsonProcessingException { + when(componentInstanceBusinessLogicMock + .updateInstanceCapability(eq(ComponentTypeEnum.SERVICE), eq(componentId), eq(componentInstanceId), any(CapabilityDefinition.class), eq(userId))) + .thenThrow(new RuntimeException()); + final var url = + String.format(UPDATE_INSTANCE_REQUIREMENT_PATH_FORMAT, ComponentTypeEnum.SERVICE_PARAM_NAME, componentId, componentInstanceId); + final Response response = target() + .path(url) + .request(MediaType.APPLICATION_JSON) + .header(Constants.USER_ID_HEADER, userId) + .put(Entity.entity(parseToJson(createDefaultUpdateMode()), MediaType.APPLICATION_JSON)); + var responseFormat = response.readEntity(ResponseFormat.class); + + final ErrorInfo errorInfo = configurationManager.getErrorConfiguration().getErrorInfo(ActionStatus.GENERAL_ERROR.name()); + assertNotNull(errorInfo); + assertEquals(errorInfo.getCode(), response.getStatus(), "The update status should be as expected"); + assertEquals(errorInfo.getMessageId(), responseFormat.getMessageId()); + assertEquals(errorInfo.getMessage(), responseFormat.getText()); + } + + @Test + void updateInstanceRequirementIncorrectComponentTypeTest() throws JsonProcessingException { + final var url = + String.format(UPDATE_INSTANCE_REQUIREMENT_PATH_FORMAT, "wrongType", componentId, componentInstanceId); + final Response response = target() + .path(url) + .request(MediaType.APPLICATION_JSON) + .header(Constants.USER_ID_HEADER, userId) + .put(Entity.entity(parseToJson(createDefaultUpdateMode()), MediaType.APPLICATION_JSON)); + var responseFormat = response.readEntity(ResponseFormat.class); + + final ErrorInfo errorInfo = configurationManager.getErrorConfiguration().getErrorInfo(ActionStatus.UNSUPPORTED_ERROR.name()); + assertNotNull(errorInfo); + assertEquals(errorInfo.getCode(), response.getStatus(), "The update status should be as expected"); + assertEquals(errorInfo.getMessageId(), responseFormat.getMessageId()); + assertEquals(errorInfo.getMessage(), responseFormat.getText()); + } + + private ComponentInstanceCapabilityUpdateModel createDefaultUpdateMode() { + var capabilityUpdateModel = new ComponentInstanceCapabilityUpdateModel(); + capabilityUpdateModel.setName("name"); + capabilityUpdateModel.setExternal(true); + capabilityUpdateModel.setOwnerId("ownerId"); + capabilityUpdateModel.setType("type"); + capabilityUpdateModel.setOwnerName("ownerName"); + capabilityUpdateModel.setUniqueId("uniqueId"); + return capabilityUpdateModel; + } + + private void assertCapabilityDefinition(final CapabilityDefinition actualCapabilityDefinition, + final CapabilityDefinition expectedCapabilityDefinition) { + assertEquals(expectedCapabilityDefinition.getUniqueId(), actualCapabilityDefinition.getUniqueId()); + assertEquals(expectedCapabilityDefinition.getName(), actualCapabilityDefinition.getName()); + assertEquals(expectedCapabilityDefinition.getOwnerId(), actualCapabilityDefinition.getOwnerId()); + assertEquals(expectedCapabilityDefinition.getOwnerName(), actualCapabilityDefinition.getOwnerName()); + assertEquals(expectedCapabilityDefinition.getType(), actualCapabilityDefinition.getType()); + assertEquals(expectedCapabilityDefinition.isExternal(), actualCapabilityDefinition.isExternal()); + } + + private <T> String parseToJson(final T object) throws JsonProcessingException { + return new ObjectMapper().writeValueAsString(object); + } + +} + diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/servlets/JerseySpringBaseTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/servlets/JerseySpringBaseTest.java index e755de12f0..7fda4edd4f 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/servlets/JerseySpringBaseTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/servlets/JerseySpringBaseTest.java @@ -77,6 +77,7 @@ public abstract class JerseySpringBaseTest extends JerseyTest { .register(jacksonJsonProvider); } + @Override protected ResourceConfig configure() { forceSet(TestProperties.CONTAINER_PORT, "0"); return configure(BaseTestConfig.class); 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 49920c3c45..5f1b62d1d4 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 @@ -307,6 +307,7 @@ public class CapabilityRequirementConverterTest { CapabilityDefinition capabilityDefinition = new CapabilityDefinition(); capabilityDefinition.setName(capabilityName); capabilityDefinition.setType("att.Node"); + capabilityDefinition.setExternal(true); List<ComponentInstanceProperty> properties = new ArrayList<>(); ComponentInstanceProperty prop = new ComponentInstanceProperty(); prop.setName(PROPERTY_NAME); diff --git a/catalog-be/src/test/resources/config/catalog-be/error-configuration.yaml b/catalog-be/src/test/resources/config/catalog-be/error-configuration.yaml index 50906d2624..b363bacd73 100644 --- a/catalog-be/src/test/resources/config/catalog-be/error-configuration.yaml +++ b/catalog-be/src/test/resources/config/catalog-be/error-configuration.yaml @@ -2266,3 +2266,31 @@ errors: message: "Error: Invalid content. Type name is not defined for policy %1", messageId: "SVC4802" } + #---------SVC4140------------------------------ + # %1 - Component uid + COMPONENT_FIND_ERROR: { + code: 500, + message: "An unexpected error occurred while retrieving the component '%1'.", + messageId: "SVC4140" + } + #---------SVC4141------------------------------ + # %1 - Component uid + COMPONENT_CAPABILITIES_FIND_ERROR: { + code: 500, + message: "An unexpected error occurred while retrieving the component '%1' capabilities.", + messageId: "SVC4141" + } + #---------SVC4142------------------------------ + # %1 - Component uid or name + COMPONENT_NOT_FOUND: { + code: 404, + message: "Component '%1' was not found.", + messageId: "SVC4142" + } + #---------SVC4143------------------------------ + # %1 - Capability name + COMPONENT_INSTANCE_CAPABILITY_UPDATE_ERROR: { + code: 500, + message: "An unexpected error occurred while updating the capability '%1'.", + messageId: "SVC4143" + }
\ No newline at end of file diff --git a/catalog-dao/src/main/java/org/openecomp/sdc/be/dao/api/ActionStatus.java b/catalog-dao/src/main/java/org/openecomp/sdc/be/dao/api/ActionStatus.java index a8f94e8eb5..619f88263c 100644 --- a/catalog-dao/src/main/java/org/openecomp/sdc/be/dao/api/ActionStatus.java +++ b/catalog-dao/src/main/java/org/openecomp/sdc/be/dao/api/ActionStatus.java @@ -31,6 +31,10 @@ public enum ActionStatus { RESOURCE_NOT_FOUND, MISSING_DERIVED_FROM_TEMPLATE, PARENT_RESOURCE_NOT_FOUND, PARENT_RESOURCE_DOES_NOT_EXTEND, INVALID_DEFAULT_VALUE, INVALID_COMPLEX_DEFAULT_VALUE, MULTIPLE_PARENT_RESOURCE_FOUND, INVALID_RESOURCE_PAYLOAD, INVALID_TOSCA_FILE_EXTENSION, INVALID_YAML_FILE, INVALID_TOSCA_TEMPLATE, NOT_RESOURCE_TOSCA_TEMPLATE, NOT_SINGLE_RESOURCE, INVALID_RESOURCE_NAMESPACE, RESOURCE_ALREADY_EXISTS, INVALID_RESOURCE_CHECKSUM, RESOURCE_CANNOT_CONTAIN_RESOURCE_INSTANCES, NO_ASSETS_FOUND, GENERIC_TYPE_NOT_FOUND, INVALID_RESOURCE_TYPE, TOSCA_PARSE_ERROR, INVALID_PM_DICTIONARY_FILE, // Service related SERVICE_TYPE_EXCEEDS_LIMIT, INVALID_SERVICE_TYPE, SERVICE_ROLE_EXCEEDS_LIMIT, INVALID_SERVICE_ROLE, INVALID_INSTANTIATION_TYPE, NOT_SERVICE_TOSCA_TEMPLATE, NOT_SINGLE_SERVICE, INVALID_SERVICE_CHECKSUM, INVALID_SERVICE_PAYLOAD, INVALID_SERVICE_NAMESPACE, SERVICE_ALREADY_EXISTS, UNSUPPORTED_DISTRIBUTION_STATUS, INVALID_NAMING_POLICY, INVALID_ENVIRONMENT_CONTEXT, NAMING_POLICY_EXCEEDS_LIMIT, MISSING_ECOMP_GENERATED_NAMING, PROPERTY_EXCEEDS_LIMIT, INVALID_PROPERY, + // Component related + COMPONENT_FIND_ERROR, + COMPONENT_CAPABILITIES_FIND_ERROR, + COMPONENT_INSTANCE_CAPABILITY_UPDATE_ERROR, // Component name related COMPONENT_NAME_ALREADY_EXIST, COMPONENT_NAME_EXCEEDS_LIMIT, MISSING_COMPONENT_NAME, INVALID_COMPONENT_NAME, // Component description related @@ -109,6 +113,7 @@ public enum ActionStatus { CONTAINER_CANNOT_CONTAIN_COMPONENT_IN_STATE, CONTAINER_CANNOT_CONTAIN_INSTANCE, MISSING_MANDATORY_PROPERTY, MANDATORY_PROPERTY_MISSING_VALUE, //Capability related CAPABILITY_NOT_FOUND, CAPABILITY_NAME_MANDATORY, CAPABILITY_TYPE_MANDATORY, CAPABILITY_NAME_ALREADY_IN_USE, MAX_OCCURRENCES_SHOULD_BE_GREATER_THAN_MIN_OCCURRENCES, CAPABILITY_DELETION_NOT_ALLOWED_USED_IN_COMPOSITION, CAPABILITY_UPDATE_NOT_ALLOWED_USED_IN_COMPOSITION, INVALID_CAPABILITY_NAME, FAILED_TO_CREATE_OR_UPDATE_CAPABILITY_PROPERTIES, CAPABILITY_PROPERTIES_NOT_FOUND, RELATIONSHIP_TYPE_ALREADY_EXIST, MISSING_RELATIONSHIP_TYPE, CAPABILITY_TYPE_CANNOT_BE_EMPTY, + COMPONENT_CAPABILITY_UPDATE_NOT_FOUND_ERROR, //Requirement related REQUIREMENT_NOT_FOUND, REQUIREMENT_NAME_MANDATORY, REQUIREMENT_CAPABILITY_MANDATORY, REQUIREMENT_NAME_ALREADY_IN_USE, REQUIREMENT_DELETION_NOT_ALLOWED_USED_IN_COMPOSITION, REQUIREMENT_UPDATE_NOT_ALLOWED_USED_IN_COMPOSITION, INVALID_REQUIREMENT_NAME, //Abstract template related diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTemplateOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTemplateOperation.java index f9e9a46698..416c701582 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTemplateOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTemplateOperation.java @@ -45,6 +45,7 @@ import org.apache.tinkerpop.gremlin.structure.Edge; import org.janusgraph.core.JanusGraphVertex; import org.openecomp.sdc.be.config.BeEcompErrorManager; import org.openecomp.sdc.be.config.ConfigurationManager; +import org.openecomp.sdc.be.dao.api.ActionStatus; import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; @@ -105,6 +106,7 @@ import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate; import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement; import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElementTypeEnum; import org.openecomp.sdc.be.model.jsonjanusgraph.enums.JsonConstantKeysEnum; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.OperationException; import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter; import org.openecomp.sdc.be.model.operations.StorageException; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; @@ -115,7 +117,9 @@ import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum; import org.openecomp.sdc.common.api.ArtifactTypeEnum; import org.openecomp.sdc.common.jsongraph.util.CommonUtility; import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum; +import org.openecomp.sdc.common.log.elements.ErrorLogOptionalData; import org.openecomp.sdc.common.log.elements.LoggerSupportability; +import org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode; import org.openecomp.sdc.common.log.enums.LogLevel; import org.openecomp.sdc.common.log.enums.LoggerSupportabilityActions; import org.openecomp.sdc.common.log.enums.StatusCode; @@ -957,11 +961,13 @@ public class NodeTemplateOperation extends BaseOperation { MapListCapabilityDataDefinition allCalculatedCap = new MapListCapabilityDataDefinition(); if (calculatedCapabilities != null) { calculatedCapabilities.forEach((key1, value1) -> { - Map<String, ListCapabilityDataDefinition> mapByType = value1.getMapToscaDataDefinition(); - mapByType.forEach((key, value) -> value.getListToscaDataDefinition().forEach(cap -> { - cap.addToPath(componentInstance.getUniqueId()); - allCalculatedCap.add(key, cap); - })); + final Map<String, ListCapabilityDataDefinition> mapByType = value1.getMapToscaDataDefinition(); + mapByType.forEach((key, value) -> value.getListToscaDataDefinition().stream() + .filter(CapabilityDataDefinition::isExternal) + .forEach(cap -> { + cap.addToPath(componentInstance.getUniqueId()); + allCalculatedCap.add(key, cap); + })); }); } MapListCapabilityDataDefinition allCaps; @@ -1068,6 +1074,93 @@ public class NodeTemplateOperation extends BaseOperation { return StorageOperationStatus.OK; } + public CapabilityDataDefinition updateComponentInstanceCapabilities(final String componentId, final String componentInstanceUniqueId, + final CapabilityDataDefinition capabilityDataDefinition) { + + final GraphVertex containerVertex = findComponentVertex(componentId).orElse(null); + if (containerVertex == null) { + throw new OperationException(ActionStatus.COMPONENT_NOT_FOUND, componentId); + } + + final Pair<GraphVertex, Map<String, MapListCapabilityDataDefinition>> capabilityVertexAndDataPair = + findCapabilityVertex(containerVertex).orElse(null); + if (capabilityVertexAndDataPair == null) { + throw new OperationException(ActionStatus.CAPABILITY_OF_INSTANCE_NOT_FOUND_ON_CONTAINER, capabilityDataDefinition.getName(), + capabilityDataDefinition.getOwnerName(), componentId); + } + final GraphVertex capabilitiesVertex = capabilityVertexAndDataPair.getLeft(); + final Map<String, MapListCapabilityDataDefinition> capabilityDataMap = capabilityVertexAndDataPair.getRight(); + + final CapabilityDataDefinition actualCapabilityDataDefinition = + findCapability(capabilityDataMap, componentInstanceUniqueId, capabilityDataDefinition.getType(), capabilityDataDefinition.getUniqueId()) + .orElse(null); + if (actualCapabilityDataDefinition == null) { + throw new OperationException(ActionStatus.CAPABILITY_OF_INSTANCE_NOT_FOUND_ON_CONTAINER, capabilityDataDefinition.getName(), + capabilityDataDefinition.getOwnerName(), componentId); + } + bindCapabilityDefinition(capabilityDataDefinition, actualCapabilityDataDefinition); + + var storageOperationStatus = updateCapabilityVertex(containerVertex, capabilitiesVertex); + if (storageOperationStatus != StorageOperationStatus.OK) { + throw new OperationException(ActionStatus.COMPONENT_INSTANCE_CAPABILITY_UPDATE_ERROR, capabilityDataDefinition.getName()); + } + return new CapabilityDataDefinition(actualCapabilityDataDefinition); + } + + private void bindCapabilityDefinition(final CapabilityDataDefinition fromCapabilityDefinition, + final CapabilityDataDefinition capabilityDefinitionToUpdate) { + capabilityDefinitionToUpdate.setExternal(fromCapabilityDefinition.isExternal()); + } + + private Optional<GraphVertex> findComponentVertex(final String componentId) { + final Either<GraphVertex, JanusGraphOperationStatus> componentEither = janusGraphDao.getVertexById(componentId, JsonParseFlagEnum.ParseAll); + if (componentEither.isRight()) { + final JanusGraphOperationStatus error = componentEither.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_FETCH_CONTAINER_VERTEX_ERROR, componentId, error); + if (error == JanusGraphOperationStatus.NOT_FOUND) { + return Optional.empty(); + } + log.error(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR, NodeTemplateOperation.class.getName(), (ErrorLogOptionalData) null, + FAILED_TO_FETCH_CONTAINER_VERTEX_ERROR, componentId, error); + throw new OperationException(ActionStatus.COMPONENT_FIND_ERROR, componentId); + } + return Optional.ofNullable(componentEither.left().value()); + } + + private Optional<Pair<GraphVertex, Map<String, MapListCapabilityDataDefinition>>> findCapabilityVertex(final GraphVertex containerVertex) { + + final Either<Pair<GraphVertex, Map<String, MapListCapabilityDataDefinition>>, StorageOperationStatus> capabilitiesEither = + fetchContainerCalculatedCapability(containerVertex, EdgeLabelEnum.CALCULATED_CAPABILITIES); + if (capabilitiesEither.isRight()) { + final StorageOperationStatus error = capabilitiesEither.right().value(); + if (error == StorageOperationStatus.NOT_FOUND) { + return Optional.empty(); + } + log.error(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR, NodeTemplateOperation.class.getName(), (ErrorLogOptionalData) null, + FAILED_TO_FETCH_CONTAINER_VERTEX_ERROR, containerVertex.getUniqueId(), error); + throw new OperationException(ActionStatus.COMPONENT_CAPABILITIES_FIND_ERROR, containerVertex.getUniqueId()); + } + return Optional.ofNullable(capabilitiesEither.left().value()); + } + + private Optional<CapabilityDataDefinition> findCapability(final Map<String, MapListCapabilityDataDefinition> capabilityMap, + final String componentInstanceUniqueId, + final String capabilityType, + final String capabilityUniqueId) { + var componentInstanceCapabilitiesMap = capabilityMap.get(componentInstanceUniqueId); + if (componentInstanceCapabilitiesMap == null || componentInstanceCapabilitiesMap.isEmpty()) { + return Optional.empty(); + } + var listCapabilityDataDefinition = componentInstanceCapabilitiesMap.getMapToscaDataDefinition().get(capabilityType); + if (listCapabilityDataDefinition == null || listCapabilityDataDefinition.isEmpty()) { + return Optional.empty(); + } + + return listCapabilityDataDefinition.getListToscaDataDefinition().stream() + .filter(e -> e.getUniqueId().equals(capabilityUniqueId)) + .findFirst(); + } + public StorageOperationStatus updateComponentInstanceRequirement(String componentId, String componentInstanceUniqueId, RequirementDataDefinition requirementDataDefinition) { Either<GraphVertex, JanusGraphOperationStatus> containerVEither = janusGraphDao @@ -1143,6 +1236,27 @@ public class NodeTemplateOperation extends BaseOperation { return StorageOperationStatus.OK; } + private StorageOperationStatus updateCapabilityVertex(final GraphVertex containerVertex, final GraphVertex capabilitiesVertex) { + containerVertex.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis()); + final Either<GraphVertex, JanusGraphOperationStatus> updateElement = janusGraphDao.updateVertex(containerVertex); + if (updateElement.isRight()) { + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update topology template '{}' with new capabilities. Error '{}'.", + containerVertex.getUniqueId(), updateElement.right().value()); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateElement.right().value()); + } + + final Either<GraphVertex, JanusGraphOperationStatus> statusEither = + updateOrCopyOnUpdate(capabilitiesVertex, containerVertex, EdgeLabelEnum.CALCULATED_CAPABILITIES); + if (statusEither.isRight()) { + JanusGraphOperationStatus error = statusEither.right().value(); + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, + "Failed to update calculated capability for container {} error {}", containerVertex.getUniqueId(), error); + return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error); + } + CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Updated calculated capability for container '{}'", containerVertex.getUniqueId()); + return StorageOperationStatus.OK; + } + private StorageOperationStatus addComponentInstanceToscaDataToNodeTypeContainer(NodeType originNodeType, ComponentInstanceDataDefinition componentInstance, GraphVertex updatedContainerVertex) { diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaOperationFacade.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaOperationFacade.java index 06e23f04ea..205a48e9b2 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaOperationFacade.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/ToscaOperationFacade.java @@ -112,6 +112,7 @@ import org.openecomp.sdc.be.model.catalog.CatalogComponent; import org.openecomp.sdc.be.model.jsonjanusgraph.config.ContainerInstanceTypesData; import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate; import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.OperationException; import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter; import org.openecomp.sdc.be.model.operations.StorageException; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; @@ -2963,6 +2964,12 @@ public class ToscaOperationFacade { return nodeTemplateOperation.updateComponentInstanceRequirement(containerComponentId, componentInstanceUniqueId, requirementDataDefinition); } + public CapabilityDataDefinition updateComponentInstanceCapability(final String containerComponentId, final String componentInstanceUniqueId, + final CapabilityDataDefinition capabilityDataDefinition) { + + return nodeTemplateOperation.updateComponentInstanceCapabilities(containerComponentId, componentInstanceUniqueId, capabilityDataDefinition); + } + public StorageOperationStatus updateComponentInstanceInterfaces(Component containerComponent, String componentInstanceUniqueId) { MapInterfaceDataDefinition mapInterfaceDataDefinition = convertComponentInstanceInterfaces(containerComponent, componentInstanceUniqueId); return topologyTemplateOperation.updateComponentInstanceInterfaces(containerComponent, componentInstanceUniqueId, mapInterfaceDataDefinition); diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/exception/OperationException.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/exception/OperationException.java new file mode 100644 index 0000000000..30323af521 --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/exception/OperationException.java @@ -0,0 +1,42 @@ +/* + * ============LICENSE_START======================================================= + * Copyright (C) 2021 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.model.jsonjanusgraph.operations.exception; + +import lombok.Getter; +import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.exception.BusinessException; + +@Getter +public class OperationException extends BusinessException { + + private final ActionStatus actionStatus; + private final String[] params; + + public OperationException(final String message) { + super(message); + actionStatus = ActionStatus.GENERAL_ERROR; + params = new String[0]; + } + + public OperationException(final ActionStatus actionStatus, String... params) { + this.actionStatus = actionStatus; + this.params = params; + } +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/ui/mapper/CapabilityMapper.java b/catalog-model/src/main/java/org/openecomp/sdc/be/ui/mapper/CapabilityMapper.java new file mode 100644 index 0000000000..4df93829fa --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/ui/mapper/CapabilityMapper.java @@ -0,0 +1,40 @@ +/* + * ============LICENSE_START======================================================= + * Copyright (C) 2021 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.ui.mapper; + +import org.openecomp.sdc.be.model.CapabilityDefinition; +import org.openecomp.sdc.be.ui.model.ComponentInstanceCapabilityUpdateModel; +import org.springframework.stereotype.Service; + +@Service +public class CapabilityMapper { + + public CapabilityDefinition mapToCapabilityDefinition(final ComponentInstanceCapabilityUpdateModel capabilityUpdateModel) { + var capabilityDefinition = new CapabilityDefinition(); + capabilityDefinition.setUniqueId(capabilityUpdateModel.getUniqueId()); + capabilityDefinition.setType(capabilityUpdateModel.getType()); + capabilityDefinition.setOwnerId(capabilityUpdateModel.getOwnerId()); + capabilityDefinition.setOwnerName(capabilityUpdateModel.getOwnerName()); + capabilityDefinition.setName(capabilityUpdateModel.getName()); + capabilityDefinition.setExternal(capabilityUpdateModel.getExternal()); + return capabilityDefinition; + } + +} diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/ui/model/ComponentInstanceCapabilityUpdateModel.java b/catalog-model/src/main/java/org/openecomp/sdc/be/ui/model/ComponentInstanceCapabilityUpdateModel.java new file mode 100644 index 0000000000..3fd74cd9e2 --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/ui/model/ComponentInstanceCapabilityUpdateModel.java @@ -0,0 +1,50 @@ +/* + * ============LICENSE_START======================================================= + * Copyright (C) 2021 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.ui.model; + +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Size; +import lombok.Data; + +/** + * Model for the component instance capability update request + */ +@Data +public class ComponentInstanceCapabilityUpdateModel { + + @NotNull + @Size(min=1) + private String type; + @NotNull + @Size(min=1) + private String name; + @NotNull + @Size(min=1) + private String ownerId; + @NotNull + @Size(min=1) + private String ownerName; + @NotNull + @Size(min=1) + private String uniqueId; + @NotNull + private Boolean external; + +} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTemplateOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTemplateOperationTest.java index cf4d6b22bf..5a02c5752f 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTemplateOperationTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTemplateOperationTest.java @@ -29,12 +29,29 @@ */ package org.openecomp.sdc.be.model.jsonjanusgraph.operations; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + import com.google.common.collect.Lists; import fj.data.Either; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; import org.apache.commons.lang3.tuple.ImmutablePair; import org.apache.tinkerpop.gremlin.structure.Direction; import org.apache.tinkerpop.gremlin.structure.Edge; -import org.apache.tinkerpop.gremlin.structure.Vertex; import org.janusgraph.core.JanusGraphVertex; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; @@ -43,46 +60,48 @@ import org.junit.jupiter.api.TestInstance.Lifecycle; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.ArgumentMatchers; import org.mockito.InjectMocks; -import org.mockito.Mock; import org.mockito.Mockito; -import org.mockito.junit.MockitoJUnitRunner; import org.mockito.junit.jupiter.MockitoExtension; +import org.openecomp.sdc.be.config.ConfigurationManager; +import org.openecomp.sdc.be.dao.api.ActionStatus; import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao; import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.datatypes.elements.*; +import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapArtifactDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapListCapabilityDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapListRequirementDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition; import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; -import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; -import org.openecomp.sdc.be.model.*; +import org.openecomp.sdc.be.model.ArtifactDefinition; +import org.openecomp.sdc.be.model.CapabilityDefinition; +import org.openecomp.sdc.be.model.CapabilityRequirementRelationship; +import org.openecomp.sdc.be.model.Component; +import org.openecomp.sdc.be.model.ComponentInstance; +import org.openecomp.sdc.be.model.ComponentInstanceAttribute; +import org.openecomp.sdc.be.model.ComponentInstanceOutput; +import org.openecomp.sdc.be.model.GroupDefinition; +import org.openecomp.sdc.be.model.ModelTestBase; +import org.openecomp.sdc.be.model.RelationshipImpl; +import org.openecomp.sdc.be.model.RelationshipInfo; +import org.openecomp.sdc.be.model.RequirementCapabilityRelDef; +import org.openecomp.sdc.be.model.Resource; +import org.openecomp.sdc.be.model.User; import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate; import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.OperationException; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.Iterator; -import java.util.List; -import java.util.Map; - -import static org.codehaus.groovy.runtime.DefaultGroovyMethods.any; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.mockito.ArgumentMatchers.anyList; -import static org.mockito.ArgumentMatchers.anyString; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - @ExtendWith(MockitoExtension.class) @TestInstance(Lifecycle.PER_CLASS) class NodeTemplateOperationTest extends ModelTestBase { @@ -205,10 +224,8 @@ class NodeTemplateOperationTest extends ModelTestBase { @Test void testGetDefaultHeatTimeout() { - Integer result; - - // default test - result = NodeTemplateOperation.getDefaultHeatTimeout(); + assertEquals(ConfigurationManager.getConfigurationManager().getConfiguration().getHeatArtifactDeploymentTimeout().getDefaultMinutes(), + NodeTemplateOperation.getDefaultHeatTimeout()); } @Test @@ -234,13 +251,8 @@ class NodeTemplateOperationTest extends ModelTestBase { } @Test - void testCreateCapPropertyKey() throws Exception { - String key = ""; - String instanceId = ""; - String result; - - // default test - result = NodeTemplateOperation.createCapPropertyKey(key, instanceId); + void testCreateCapPropertyKey() { + assertEquals("instanceId#instanceId#key", NodeTemplateOperation.createCapPropertyKey("key", "instanceId")); } @Test @@ -438,6 +450,119 @@ class NodeTemplateOperationTest extends ModelTestBase { eq(componentInstanceOutputList), ArgumentMatchers.anyList(), eq(JsonPresentationFields.NAME)); } + @Test + void updateComponentInstanceCapabilitiesSuccessTest() { + final var capabilityUniqueId = "capabilityUniqueId"; + final var capabilityType = "capabilityType"; + final var componentInstanceId = "componentInstanceId"; + + final var nodeTemplateOperation = spy(operation); + final var capabilityDefinitionDatabase = new CapabilityDataDefinition(); + capabilityDefinitionDatabase.setUniqueId(capabilityUniqueId); + capabilityDefinitionDatabase.setType(capabilityType); + capabilityDefinitionDatabase.setExternal(false); + final var capabilityDefinitionToUpdate = new CapabilityDataDefinition(); + capabilityDefinitionToUpdate.setUniqueId(capabilityUniqueId); + capabilityDefinitionToUpdate.setType(capabilityType); + capabilityDefinitionToUpdate.setExternal(true); + final Map<String, MapListCapabilityDataDefinition> capabilityByInstanceMap = new HashMap<>(); + var mapListCapabilityDataDefinition = new MapListCapabilityDataDefinition(); + mapListCapabilityDataDefinition.add(capabilityDefinitionDatabase.getType(), capabilityDefinitionDatabase); + capabilityByInstanceMap.put(componentInstanceId, mapListCapabilityDataDefinition); + + final GraphVertex componentVertex = Mockito.mock(GraphVertex.class); + final GraphVertex capabilitiesVertex = Mockito.mock(GraphVertex.class); + doReturn(capabilityByInstanceMap).when(capabilitiesVertex).getJson(); + when(janusGraphDao.getVertexById(COMPONENT_ID, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(componentVertex)); + when(janusGraphDao.getChildVertex(componentVertex, EdgeLabelEnum.CALCULATED_CAPABILITIES, JsonParseFlagEnum.ParseJson)) + .thenReturn(Either.left(capabilitiesVertex)); + when(janusGraphDao.updateVertex(componentVertex)).thenReturn(Either.left(componentVertex)); + doReturn(Either.left(capabilitiesVertex)) + .when(nodeTemplateOperation).updateOrCopyOnUpdate(capabilitiesVertex, componentVertex, EdgeLabelEnum.CALCULATED_CAPABILITIES); + final CapabilityDataDefinition actualCapabilityDataDefinition = nodeTemplateOperation + .updateComponentInstanceCapabilities(COMPONENT_ID, componentInstanceId, capabilityDefinitionToUpdate); + assertTrue(actualCapabilityDataDefinition.isExternal()); + } + + @Test + void updateComponentInstanceCapabilitiesTest_capabilityNotFound() { + final var componentInstanceId = "componentInstanceId"; + var capabilityDataDefinition = new CapabilityDataDefinition(); + capabilityDataDefinition.setType("aCapabilityType"); + final GraphVertex componentVertex = Mockito.mock(GraphVertex.class); + final GraphVertex calculatedCapabilityVertex = Mockito.mock(GraphVertex.class); + //no capabilities found + when(janusGraphDao.getVertexById(COMPONENT_ID, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(componentVertex)); + when(janusGraphDao.getChildVertex(componentVertex, EdgeLabelEnum.CALCULATED_CAPABILITIES, JsonParseFlagEnum.ParseJson)) + .thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)); + OperationException actualException = assertThrows(OperationException.class, () -> + operation.updateComponentInstanceCapabilities(COMPONENT_ID, componentInstanceId, capabilityDataDefinition)); + assertEquals(ActionStatus.CAPABILITY_OF_INSTANCE_NOT_FOUND_ON_CONTAINER, actualException.getActionStatus()); + assertEquals(actualException.getParams().length, 3); + assertEquals(capabilityDataDefinition.getName(), actualException.getParams()[0]); + assertEquals(capabilityDataDefinition.getOwnerName(), actualException.getParams()[1]); + assertEquals(COMPONENT_ID, actualException.getParams()[2]); + + //found capabilities, but not for the provided instance id + when(janusGraphDao.getChildVertex(componentVertex, EdgeLabelEnum.CALCULATED_CAPABILITIES, JsonParseFlagEnum.ParseJson)) + .thenReturn(Either.left(calculatedCapabilityVertex)); + actualException = assertThrows(OperationException.class, () -> + operation.updateComponentInstanceCapabilities(COMPONENT_ID, "componentInstanceId", capabilityDataDefinition)); + assertEquals(ActionStatus.CAPABILITY_OF_INSTANCE_NOT_FOUND_ON_CONTAINER, actualException.getActionStatus()); + assertEquals(actualException.getParams().length, 3); + assertEquals(capabilityDataDefinition.getName(), actualException.getParams()[0]); + assertEquals(capabilityDataDefinition.getOwnerName(), actualException.getParams()[1]); + assertEquals(COMPONENT_ID, actualException.getParams()[2]); + + //found capabilities for the instance id, but not with the provided capability type + final Map<String, MapListCapabilityDataDefinition> capabilityByInstanceMap = new HashMap<>(); + var mapListCapabilityDataDefinition = new MapListCapabilityDataDefinition(); + mapListCapabilityDataDefinition.add("anotherCapabilityType", new CapabilityDataDefinition()); + capabilityByInstanceMap.put(componentInstanceId, mapListCapabilityDataDefinition); + doReturn(capabilityByInstanceMap).when(calculatedCapabilityVertex).getJson(); + actualException = assertThrows(OperationException.class, () -> + operation.updateComponentInstanceCapabilities(COMPONENT_ID, "componentInstanceId", capabilityDataDefinition)); + assertEquals(ActionStatus.CAPABILITY_OF_INSTANCE_NOT_FOUND_ON_CONTAINER, actualException.getActionStatus()); + assertEquals(actualException.getParams().length, 3); + assertEquals(capabilityDataDefinition.getName(), actualException.getParams()[0]); + assertEquals(capabilityDataDefinition.getOwnerName(), actualException.getParams()[1]); + assertEquals(COMPONENT_ID, actualException.getParams()[2]); + } + + @Test + void updateComponentInstanceCapabilitiesTest_capabilityFindError() { + final GraphVertex componentVertex = Mockito.mock(GraphVertex.class); + when(componentVertex.getUniqueId()).thenReturn(COMPONENT_ID); + when(janusGraphDao.getVertexById(COMPONENT_ID, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(componentVertex)); + when(janusGraphDao.getChildVertex(componentVertex, EdgeLabelEnum.CALCULATED_CAPABILITIES, JsonParseFlagEnum.ParseJson)) + .thenReturn(Either.right(JanusGraphOperationStatus.GENERAL_ERROR)); + final OperationException actualException = assertThrows(OperationException.class, () -> + operation.updateComponentInstanceCapabilities(COMPONENT_ID, "componentInstanceId", new CapabilityDataDefinition())); + assertEquals(ActionStatus.COMPONENT_CAPABILITIES_FIND_ERROR, actualException.getActionStatus()); + assertEquals(actualException.getParams().length, 1); + assertEquals(COMPONENT_ID, actualException.getParams()[0]); + } + + @Test + void updateComponentInstanceCapabilitiesTest_componentNotFound() { + when(janusGraphDao.getVertexById(COMPONENT_ID, JsonParseFlagEnum.ParseAll)).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)); + final OperationException actualException = assertThrows(OperationException.class, () -> + operation.updateComponentInstanceCapabilities(COMPONENT_ID, "componentInstanceId", new CapabilityDataDefinition())); + assertEquals(ActionStatus.COMPONENT_NOT_FOUND, actualException.getActionStatus()); + assertEquals(actualException.getParams().length, 1); + assertEquals(COMPONENT_ID, actualException.getParams()[0]); + } + + @Test + void updateComponentInstanceCapabilitiesTest_componentFindError() { + when(janusGraphDao.getVertexById(COMPONENT_ID, JsonParseFlagEnum.ParseAll)).thenReturn(Either.right(JanusGraphOperationStatus.GENERAL_ERROR)); + final OperationException actualException = assertThrows(OperationException.class, () -> + operation.updateComponentInstanceCapabilities(COMPONENT_ID, "componentInstanceId", new CapabilityDataDefinition())); + assertEquals(ActionStatus.COMPONENT_FIND_ERROR, actualException.getActionStatus()); + assertEquals(actualException.getParams().length, 1); + assertEquals(COMPONENT_ID, actualException.getParams()[0]); + } + private ComponentInstance createCompInstance() { ComponentInstance componentInstance = new ComponentInstance(); String id = "id"; diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/ui/mapper/CapabilityMapperTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/ui/mapper/CapabilityMapperTest.java new file mode 100644 index 0000000000..6e147281b8 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/ui/mapper/CapabilityMapperTest.java @@ -0,0 +1,60 @@ +/* + * ============LICENSE_START======================================================= + * Copyright (C) 2021 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.ui.mapper; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.openecomp.sdc.be.model.CapabilityDefinition; +import org.openecomp.sdc.be.ui.model.ComponentInstanceCapabilityUpdateModel; + +class CapabilityMapperTest { + + private CapabilityMapper capabilityMapper; + + @BeforeEach + void beforeEach() { + capabilityMapper = new CapabilityMapper(); + } + + @Test + void mapToCapabilityDefinitionTest() { + final ComponentInstanceCapabilityUpdateModel capabilityUpdateModel = new ComponentInstanceCapabilityUpdateModel(); + capabilityUpdateModel.setUniqueId("uniqueId"); + capabilityUpdateModel.setName("name"); + capabilityUpdateModel.setExternal(true); + capabilityUpdateModel.setOwnerId("ownerId"); + capabilityUpdateModel.setType("type"); + capabilityUpdateModel.setOwnerName("ownerName"); + final CapabilityDefinition capabilityDefinition = capabilityMapper.mapToCapabilityDefinition(capabilityUpdateModel); + assertCapabilityDefinition(capabilityDefinition, capabilityUpdateModel); + } + + private void assertCapabilityDefinition(final CapabilityDefinition actualCapabilityDefinition, + final ComponentInstanceCapabilityUpdateModel expectedCapabilityDefinition) { + assertEquals(expectedCapabilityDefinition.getUniqueId(), actualCapabilityDefinition.getUniqueId()); + assertEquals(expectedCapabilityDefinition.getName(), actualCapabilityDefinition.getName()); + assertEquals(expectedCapabilityDefinition.getOwnerId(), actualCapabilityDefinition.getOwnerId()); + assertEquals(expectedCapabilityDefinition.getOwnerName(), actualCapabilityDefinition.getOwnerName()); + assertEquals(expectedCapabilityDefinition.getType(), actualCapabilityDefinition.getType()); + assertEquals(expectedCapabilityDefinition.getExternal(), actualCapabilityDefinition.isExternal()); + } +}
\ No newline at end of file diff --git a/catalog-ui/src/app/models/capability.ts b/catalog-ui/src/app/models/capability.ts index f365dc4940..b377ed9edd 100644 --- a/catalog-ui/src/app/models/capability.ts +++ b/catalog-ui/src/app/models/capability.ts @@ -62,6 +62,7 @@ export class Capability implements RequirementCapabilityModel { description: string; validSourceTypes: string[]; properties: PropertyModel[]; + external: boolean; // custom selected: boolean; @@ -84,6 +85,7 @@ export class Capability implements RequirementCapabilityModel { this.description = capability.description; this.validSourceTypes = capability.validSourceTypes; this.selected = capability.selected; + this.external = capability.external; this.initFilterTerm(); } diff --git a/catalog-ui/src/app/ng2/pages/composition/graph/composition-graph.component.ts b/catalog-ui/src/app/ng2/pages/composition/graph/composition-graph.component.ts index 3cab4b300f..8d2357d6ad 100644 --- a/catalog-ui/src/app/ng2/pages/composition/graph/composition-graph.component.ts +++ b/catalog-ui/src/app/ng2/pages/composition/graph/composition-graph.component.ts @@ -25,7 +25,8 @@ import { ZoneInstanceAssignmentType, ZoneInstanceMode, ZoneInstanceType, - Requirement + Requirement, + Capability } from 'app/models'; import { ForwardingPath } from 'app/models/forwarding-path'; import { CompositionCiServicePathLink } from 'app/models/graph/graph-links/composition-graph-links/composition-ci-service-path-link'; @@ -649,6 +650,14 @@ export class CompositionGraphComponent implements AfterViewInit { .find(r => r.uniqueId === requirement.uniqueId).external = requirement.external; }); + this.eventListenerService.registerObserverCallback(GRAPH_EVENTS.ON_COMPONENT_INSTANCE_CAPABILITY_EXTERNAL_CHANGED, + (uniqueId: string, capability: Capability) => { + const graphCapability = this._cy.getElementById(uniqueId).data() + .componentInstance.capabilities[capability.type].find(cap => cap.uniqueId === capability.uniqueId); + graphCapability.external = capability.external; + } + ); + this.eventListenerService.registerObserverCallback(GRAPH_EVENTS.ON_DELETE_COMPONENT_INSTANCE, (componentInstanceId: string) => { const nodeToDelete = this._cy.getElementById(componentInstanceId); this.nodesGraphUtils.deleteNode(this._cy, this.topologyTemplate, nodeToDelete); diff --git a/catalog-ui/src/app/ng2/pages/composition/panel/panel-tabs/req-capabilities-tab/req-capabilities-tab.component.html b/catalog-ui/src/app/ng2/pages/composition/panel/panel-tabs/req-capabilities-tab/req-capabilities-tab.component.html index c73f69734f..ad25aabefd 100644 --- a/catalog-ui/src/app/ng2/pages/composition/panel/panel-tabs/req-capabilities-tab/req-capabilities-tab.component.html +++ b/catalog-ui/src/app/ng2/pages/composition/panel/panel-tabs/req-capabilities-tab/req-capabilities-tab.component.html @@ -5,6 +5,16 @@ <div *ngFor="let capability of capabilities" class="relations-details-container"> <div class="relations-name">{{capability.name}} </div> <div class="relations-desc"> {{capability.type}} </div> + <div class="checkbox-label-mark-as-external" *ngIf="isComponentInstanceSelected"> + <checkbox + class="checkbox-label" + [attr.data-tests-id]="'checkbox-external-cap-' + capability.name" + [label]="'External'" + (checkedChange)="onMarkCapabilityAsExternal(capability)" + [(checked)]="capability.external" + [disabled]="isViewOnly"> + </checkbox> + </div> </div> </sdc-accordion> </div> @@ -19,10 +29,20 @@ <ng-template #complexComponentTemplate> <sdc-accordion *ngIf="capabilitiesInstancesMap" [title]="'Capabilities'" [arrow-direction]="'right'" [testId]="'Capabilities-accordion'"> <sdc-accordion *ngFor="let key of objectKeys(capabilitiesInstancesMap); let i = index" [title]="key"> - <div *ngFor="let capability of capabilitiesInstancesMap[key]" class="relations-details-container"> - <div class="relations-name">{{capability.name}} </div> - <div class="relations-desc"> {{capability.type}} </div> - </div> + <div *ngFor="let capability of capabilitiesInstancesMap[key]" class="relations-details-container"> + <div class="relations-name">{{capability.name}} </div> + <div class="relations-desc"> {{capability.type}} </div> + <div class="checkbox-label-mark-as-external" *ngIf="isComponentInstanceSelected"> + <checkbox + class="checkbox-label" + [attr.data-tests-id]="'checkbox-external-cap-' + capability.name" + [label]="'External'" + (checkedChange)="onMarkCapabilityAsExternal(capability)" + [(checked)]="capability.external" + [disabled]="isViewOnly"> + </checkbox> + </div> + </div> </sdc-accordion> </sdc-accordion> diff --git a/catalog-ui/src/app/ng2/pages/composition/panel/panel-tabs/req-capabilities-tab/req-capabilities-tab.component.ts b/catalog-ui/src/app/ng2/pages/composition/panel/panel-tabs/req-capabilities-tab/req-capabilities-tab.component.ts index 7c91cbc4b8..7bb88c7f59 100644 --- a/catalog-ui/src/app/ng2/pages/composition/panel/panel-tabs/req-capabilities-tab/req-capabilities-tab.component.ts +++ b/catalog-ui/src/app/ng2/pages/composition/panel/panel-tabs/req-capabilities-tab/req-capabilities-tab.component.ts @@ -1,5 +1,5 @@ import { Component, OnInit, Input, OnDestroy } from '@angular/core'; -import { Component as TopologyTemplate, Capability, Requirement, CapabilitiesGroup, RequirementsGroup, ComponentInstance, FullComponentInstance } from "app/models"; +import { Component as TopologyTemplate, Capability, Requirement, CapabilitiesGroup, RequirementsGroup, FullComponentInstance } from "app/models"; import { Store } from "@ngxs/store"; import { GRAPH_EVENTS } from "app/utils"; import { ComponentGenericResponse } from "app/ng2/services/responses/component-generic-response"; @@ -8,6 +8,7 @@ import { EventListenerService } from "app/services"; import { WorkspaceService } from "app/ng2/pages/workspace/workspace.service"; import { CompositionService } from "app/ng2/pages/composition/composition.service"; import {SelectedComponentType, TogglePanelLoadingAction} from "../../../common/store/graph.actions"; +import {ComponentInstanceServiceNg2} from "../../../../../services/component-instance-services/component-instance.service"; export class InstanceCapabilitiesMap { @@ -42,7 +43,8 @@ export class ReqAndCapabilitiesTabComponent implements OnInit, OnDestroy { private topologyTemplateService:TopologyTemplateService, private workspaceService: WorkspaceService, private compositionService: CompositionService, - private eventListenerService:EventListenerService) { } + private eventListenerService:EventListenerService, + private componentInstanceService: ComponentInstanceServiceNg2) { } ngOnInit(): void { @@ -112,13 +114,19 @@ export class ReqAndCapabilitiesTabComponent implements OnInit, OnDestroy { private initInstancesMap = ():void => { this.capabilitiesInstancesMap = new InstanceCapabilitiesMap(); - _.forEach(this.capabilities, (capability:Capability) => { - if (this.capabilitiesInstancesMap[capability.ownerName]) { - this.capabilitiesInstancesMap[capability.ownerName] = this.capabilitiesInstancesMap[capability.ownerName].concat(capability); - } else { - this.capabilitiesInstancesMap[capability.ownerName] = new Array<Capability>(capability); + let capabilityList: Array<Capability> = this.capabilities; + if (capabilityList) { + if (!this.isComponentInstanceSelected) { + capabilityList = capabilityList.filter(value => value.external); } - }); + capabilityList.forEach(capability => { + if (this.capabilitiesInstancesMap[capability.ownerName]) { + this.capabilitiesInstancesMap[capability.ownerName] = this.capabilitiesInstancesMap[capability.ownerName].concat(capability); + } else { + this.capabilitiesInstancesMap[capability.ownerName] = new Array<Capability>(capability); + } + }); + } this.requirementsInstancesMap = new InstanceRequirementsMap(); _.forEach(this.requirements, (requirement:Requirement) => { @@ -161,7 +169,21 @@ export class ReqAndCapabilitiesTabComponent implements OnInit, OnDestroy { } - - + onMarkCapabilityAsExternal(capability: Capability) { + this.store.dispatch(new TogglePanelLoadingAction({isLoading: true})); + capability.external = !capability.external; + const componentId = this.workspaceService.metadata.uniqueId; + const componentInstanceId = this.component.uniqueId; + this.componentInstanceService + .updateInstanceCapability(this.workspaceService.metadata.getTypeUrl(), componentId, componentInstanceId, capability) + .subscribe(() => { + this.eventListenerService.notifyObservers(GRAPH_EVENTS.ON_COMPONENT_INSTANCE_CAPABILITY_EXTERNAL_CHANGED, componentInstanceId, capability); + this.store.dispatch(new TogglePanelLoadingAction({isLoading: false})); + } , (error) => { + console.error("An error has occurred while setting capability '" + capability.name + "' external", error); + capability.external = !capability.external; + this.store.dispatch(new TogglePanelLoadingAction({isLoading: false})); + }); + } } diff --git a/catalog-ui/src/app/ng2/pages/composition/panel/panel-tabs/req-capabilities-tab/requirement-list/requirement-list.component.html b/catalog-ui/src/app/ng2/pages/composition/panel/panel-tabs/req-capabilities-tab/requirement-list/requirement-list.component.html index ebaed0441a..ee8277971b 100644 --- a/catalog-ui/src/app/ng2/pages/composition/panel/panel-tabs/req-capabilities-tab/requirement-list/requirement-list.component.html +++ b/catalog-ui/src/app/ng2/pages/composition/panel/panel-tabs/req-capabilities-tab/requirement-list/requirement-list.component.html @@ -17,7 +17,7 @@ *ngIf="isInstanceSelected"> <checkbox class="checkbox-label" - [attr.data-tests-id]="'checkbox-mark-as-external-' + requirement.name" + [attr.data-tests-id]="'checkbox-external-req-' + requirement.name" [label]="'External'" (checkedChange)="onMarkAsExternal(requirement)" [(checked)]="requirement.external" diff --git a/catalog-ui/src/app/ng2/services/component-instance-services/component-instance.service.spec.ts b/catalog-ui/src/app/ng2/services/component-instance-services/component-instance.service.spec.ts new file mode 100644 index 0000000000..4de556cdd5 --- /dev/null +++ b/catalog-ui/src/app/ng2/services/component-instance-services/component-instance.service.spec.ts @@ -0,0 +1,80 @@ +/* + * ============LICENSE_START======================================================= + * Copyright (C) 2021 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========================================================= + */ + +import {TestBed} from '@angular/core/testing'; +import {ISdcConfig, SdcConfigToken} from "../../config/sdc-config.config"; +import {ComponentInstanceServiceNg2} from "./component-instance.service"; +import {Capability} from "../../../models/capability"; +import {HttpClientTestingModule, HttpTestingController} from "@angular/common/http/testing"; + +describe('ComponentInstanceServiceNg2', () => { + let httpTestingController: HttpTestingController; + let componentInstanceService: ComponentInstanceServiceNg2; + let rootApi: string = 'http://localhost/' + let componentApiRoot: string = 'catalog/' + beforeEach(() => { + const sdcConfigToken: Partial<ISdcConfig> = { + 'api': { + 'root': rootApi, + 'component_api_root': componentApiRoot, + } + }; + TestBed.configureTestingModule({ + providers: [ComponentInstanceServiceNg2, + {provide: SdcConfigToken, useValue: sdcConfigToken} + ], + imports: [HttpClientTestingModule] + }); + httpTestingController = TestBed.get(HttpTestingController); + componentInstanceService = TestBed.get(ComponentInstanceServiceNg2); + }); + + it('should be created', () => { + expect(componentInstanceService).toBeTruthy(); + }); + + it('updateInstanceCapability call should return the expected data', () => { + const capabilityToUpdate = new Capability(); + capabilityToUpdate.type = "tosca.capabilities.Scalable"; + capabilityToUpdate.name = "capScalable"; + capabilityToUpdate.ownerId = "191f8a83-d362-4db4-af30-75d71a55c959.a822dd1c-3560-47ea-b8a2-f557fed5e186.vfcapreq10"; + capabilityToUpdate.uniqueId = "2047eb3c-de31-4413-a358-8710a3dd2670"; + capabilityToUpdate.external = true; + + const componentTypeUrl = "services/"; + let actualCapability: Capability; + componentInstanceService.updateInstanceCapability(componentTypeUrl, "componentId", "componentInstanceId", capabilityToUpdate) + .subscribe(capability => { + actualCapability = capability; + }); + + const request = + httpTestingController.expectOne(`${rootApi}${componentApiRoot}${componentTypeUrl}componentId/componentInstances/componentInstanceId/capability/`); + + expect(request.request.method).toEqual('PUT'); + + request.flush(capabilityToUpdate); + expect(actualCapability.name).toEqual(capabilityToUpdate.name); + expect(actualCapability.type).toEqual(capabilityToUpdate.type); + expect(actualCapability.ownerId).toEqual(capabilityToUpdate.ownerId); + expect(actualCapability.uniqueId).toEqual(capabilityToUpdate.uniqueId); + expect(actualCapability.external).toEqual(capabilityToUpdate.external); + }); + +}); diff --git a/catalog-ui/src/app/ng2/services/component-instance-services/component-instance.service.ts b/catalog-ui/src/app/ng2/services/component-instance-services/component-instance.service.ts index 5ae2918805..1e4ddda9c0 100644 --- a/catalog-ui/src/app/ng2/services/component-instance-services/component-instance.service.ts +++ b/catalog-ui/src/app/ng2/services/component-instance-services/component-instance.service.ts @@ -18,15 +18,25 @@ * ============LICENSE_END========================================================= */ -import {Injectable, Inject} from '@angular/core'; -import { Observable } from 'rxjs/Observable'; -import {PropertyFEModel, PropertyBEModel, Requirement} from "app/models"; -import {CommonUtils, ComponentType, ServerTypeUrl, ComponentInstanceFactory} from "app/utils"; -import {Component, ComponentInstance, Capability, PropertyModel, ArtifactGroupModel, ArtifactModel, AttributeModel, IFileDownload} from "app/models"; -import {SdcConfigToken, ISdcConfig} from "../../config/sdc-config.config"; -import { HttpClient, HttpHeaders } from '@angular/common/http'; -import { InputBEModel } from '../../../models/properties-inputs/input-be-model'; -import { HttpHelperService } from '../http-hepler.service'; +import {Inject, Injectable} from '@angular/core'; +import {Observable} from 'rxjs/Observable'; +import { + ArtifactGroupModel, + ArtifactModel, + AttributeModel, + Capability, + Component, + ComponentInstance, + IFileDownload, + PropertyBEModel, + PropertyModel, + Requirement +} from "app/models"; +import {CommonUtils, ComponentInstanceFactory, ComponentType, ServerTypeUrl} from "app/utils"; +import {ISdcConfig, SdcConfigToken} from "../../config/sdc-config.config"; +import {HttpClient, HttpHeaders} from '@angular/common/http'; +import {InputBEModel} from '../../../models/properties-inputs/input-be-model'; +import {HttpHelperService} from '../http-hepler.service'; import {AttributeBEModel} from "../../../models/attributes-outputs/attribute-be-model"; import {OutputBEModel} from "../../../models/attributes-outputs/output-be-model"; @@ -158,6 +168,11 @@ export class ComponentInstanceServiceNg2 { '/requirementName/' + requirement.name, requirement); } + updateInstanceCapability(componentTypeUrl: string, componentId: string, componentInstanceId: string, capability: Capability): Observable<Capability> { + const url = `${this.baseUrl}${componentTypeUrl}${componentId}/componentInstances/${componentInstanceId}/capability/`; + return this.http.put<Capability>(url, capability); + } + updateInstanceInputs(component: Component, componentInstanceId: string, inputs: PropertyBEModel[]): Observable<PropertyBEModel[]> { return this.http.post<Array<PropertyModel>>(this.baseUrl + component.getTypeUrl() + component.uniqueId + '/resourceInstance/' + componentInstanceId + '/inputs', inputs) @@ -203,7 +218,6 @@ export class ComponentInstanceServiceNg2 { } addInstanceArtifact = (componentType:string, componentId:string, instanceId:string, artifact:ArtifactModel):Observable<ArtifactModel> => { - // let deferred = this.$q.defer<ArtifactModel>(); let headerObj = new HttpHeaders(); if (artifact.payloadData) { headerObj = headerObj.set('Content-MD5', HttpHelperService.getHeaderMd5(artifact)); @@ -217,7 +231,7 @@ export class ComponentInstanceServiceNg2 { updateInstanceArtifact = (componentType:string, componentId:string, instanceId:string, artifact:ArtifactModel):Observable<ArtifactModel> => { return this.http.post<ArtifactModel>(this.baseUrl + this.getServerTypeUrl(componentType) + componentId + '/resourceInstance/' + instanceId + '/artifacts/' + artifact.uniqueId, artifact).map((res) => { return new ArtifactModel(res); - });; + }); }; deleteInstanceArtifact = (componentId:string, componentType:string, instanceId:string, artifactId:string, artifactLabel:string):Observable<ArtifactModel> => { diff --git a/catalog-ui/src/app/utils/constants.ts b/catalog-ui/src/app/utils/constants.ts index 3e86ec9e96..f7cbf8d7b0 100644 --- a/catalog-ui/src/app/utils/constants.ts +++ b/catalog-ui/src/app/utils/constants.ts @@ -349,6 +349,7 @@ export class GRAPH_EVENTS { static ON_PALETTE_COMPONENT_HIDE_POPUP_PANEL = 'onPaletteComponentHidePopupPanel'; static ON_COMPONENT_INSTANCE_NAME_CHANGED = 'onComponentInstanceNameChanged'; static ON_COMPONENT_INSTANCE_REQUIREMENT_EXTERNAL_CHANGED = 'onComponentInstanceRequirementExternalChanged' + static ON_COMPONENT_INSTANCE_CAPABILITY_EXTERNAL_CHANGED = 'onComponentInstanceCapabilityExternalChanged' static ON_ZONE_INSTANCE_NAME_CHANGED = 'onZoneInstanceNameChanged'; static ON_DELETE_COMPONENT_INSTANCE = 'onDeleteComponentInstance'; static ON_DELETE_ZONE_INSTANCE = 'onDeleteZoneInstance'; diff --git a/common-app-api/src/main/java/org/openecomp/sdc/exception/ResponseFormat.java b/common-app-api/src/main/java/org/openecomp/sdc/exception/ResponseFormat.java index b0467425ec..2840ccd3b4 100644 --- a/common-app-api/src/main/java/org/openecomp/sdc/exception/ResponseFormat.java +++ b/common-app-api/src/main/java/org/openecomp/sdc/exception/ResponseFormat.java @@ -19,6 +19,8 @@ */ package org.openecomp.sdc.exception; +import lombok.Setter; + /** * Nested POJOs to express required JSON format of the error * <p> @@ -28,6 +30,7 @@ package org.openecomp.sdc.exception; */ public class ResponseFormat { + @Setter private int status; private RequestErrorWrapper requestErrorWrapper; @@ -40,10 +43,6 @@ public class ResponseFormat { this.status = status; } - public void setStatus(int status) { - this.status = status; - } - public Integer getStatus() { return status; } @@ -153,9 +152,6 @@ public class ResponseFormat { @SuppressWarnings("unused") private OkResponseInfo okResponseInfo; - public RequestError() { - } - public PolicyException getPolicyException() { return policyException; } diff --git a/common-app-logging/src/main/java/org/openecomp/sdc/common/log/enums/LoggerSupportabilityActions.java b/common-app-logging/src/main/java/org/openecomp/sdc/common/log/enums/LoggerSupportabilityActions.java index 88b6dbfb6a..253a41f8cb 100644 --- a/common-app-logging/src/main/java/org/openecomp/sdc/common/log/enums/LoggerSupportabilityActions.java +++ b/common-app-logging/src/main/java/org/openecomp/sdc/common/log/enums/LoggerSupportabilityActions.java @@ -79,6 +79,7 @@ public enum LoggerSupportabilityActions { UPDATE_GROUP_MEMBERS("UPDATE GROUP MEMBERS"), UPDATE_INSTANCE_CAPABILITY_PROPERTY("UPDATE INSTANCE CAPABILITY PROPERTY"), UPDATE_INSTANCE_REQUIREMENT("UPDATE INSTANCE REQUIREMENT"), + UPDATE_INSTANCE_CAPABILITY("UPDATE INSTANCE CAPABILITY"), UPDATE_POLICY_TARGET("UPDATE POLICY TARGET"), UPDATE_POLICIES_PROPERTIES("UPDATE POLICIES PROPERTIES"); // @formatter:on diff --git a/common-be/src/main/java/org/openecomp/sdc/be/datatypes/elements/CapabilityDataDefinition.java b/common-be/src/main/java/org/openecomp/sdc/be/datatypes/elements/CapabilityDataDefinition.java index 78bfe50d5c..3345c95946 100644 --- a/common-be/src/main/java/org/openecomp/sdc/be/datatypes/elements/CapabilityDataDefinition.java +++ b/common-be/src/main/java/org/openecomp/sdc/be/datatypes/elements/CapabilityDataDefinition.java @@ -21,6 +21,8 @@ package org.openecomp.sdc.be.datatypes.elements; import com.google.common.collect.Lists; +import lombok.Getter; +import lombok.Setter; import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; @@ -35,6 +37,10 @@ public class CapabilityDataDefinition extends ToscaDataDefinition { public static final String MIN_OCCURRENCES = "0"; public static final String MAX_OCCURRENCES = "UNBOUNDED"; + @Getter + @Setter + private boolean external = false; + /** * The default constructor initializing limits of the occurrences */ @@ -45,11 +51,11 @@ public class CapabilityDataDefinition extends ToscaDataDefinition { } /** - * Deep copy constructor + * Deep copy constructor. * - * @param other + * @param other the capability data definition to copy */ - public CapabilityDataDefinition(CapabilityDataDefinition other) { + public CapabilityDataDefinition(final CapabilityDataDefinition other) { this.setUniqueId(other.getUniqueId()); this.setType(other.getType()); this.setDescription(other.getDescription()); @@ -84,6 +90,7 @@ public class CapabilityDataDefinition extends ToscaDataDefinition { this.setSource(other.getSource()); this.setOwnerType(other.getOwnerType()); + this.setExternal(other.isExternal()); } public CapabilityDataDefinition(CapabilityTypeDataDefinition other) { @@ -422,11 +429,11 @@ public class CapabilityDataDefinition extends ToscaDataDefinition { String maxOccurrences = this.getMaxOccurrences(); String source = this.getSource(); - return "CapabilityDefinition [uniqueId=" + uniqueId + ", description=" + description + ", name=" + name - + ", type=" + type + ", validSourceTypes=" + validSourceTypes + ", capabilitySources=" - + capabilitySources + ", ownerId=" + ownerId + ", ownerName=" + ownerName - + ", minOccurrences=" + minOccurrences + ", maxOccurrences=" + maxOccurrences + ", path=" + path + ", source=" + source + "]"; + + ", type=" + type + ", validSourceTypes=" + validSourceTypes + ", capabilitySources=" + + capabilitySources + ", ownerId=" + ownerId + ", ownerName=" + ownerName + + ", minOccurrences=" + minOccurrences + ", maxOccurrences=" + maxOccurrences + ", path=" + path + ", source=" + source + + ", external=" + external + "]"; } public enum OwnerType { diff --git a/common-be/src/main/java/org/openecomp/sdc/be/exception/BusinessException.java b/common-be/src/main/java/org/openecomp/sdc/be/exception/BusinessException.java new file mode 100644 index 0000000000..69fb00f3b5 --- /dev/null +++ b/common-be/src/main/java/org/openecomp/sdc/be/exception/BusinessException.java @@ -0,0 +1,34 @@ +/* + * ============LICENSE_START======================================================= + * Copyright (C) 2021 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.exception; + +public abstract class BusinessException extends RuntimeException { + + protected BusinessException() { + } + + protected BusinessException(final String message) { + super(message); + } + + protected BusinessException(final String message, final Throwable cause) { + super(message, cause); + } +} diff --git a/integration-tests/src/test/java/org/onap/sdc/frontend/ci/tests/pages/component/workspace/CompositionRequirementsCapabilitiesTab.java b/integration-tests/src/test/java/org/onap/sdc/frontend/ci/tests/pages/component/workspace/CompositionRequirementsCapabilitiesTab.java index bee2d3a339..2ea7437416 100644 --- a/integration-tests/src/test/java/org/onap/sdc/frontend/ci/tests/pages/component/workspace/CompositionRequirementsCapabilitiesTab.java +++ b/integration-tests/src/test/java/org/onap/sdc/frontend/ci/tests/pages/component/workspace/CompositionRequirementsCapabilitiesTab.java @@ -67,11 +67,11 @@ public class CompositionRequirementsCapabilitiesTab extends AbstractPageObject { } private void loadRequirements() { - final List<WebElement> webElements = waitForAllElementsVisibility(By.xpath("//checkbox[@data-tests-id]")); + final List<WebElement> webElements = waitForAllElementsVisibility(By.xpath(XpathSelector.REQUIREMENT_EXTERNAL_CHECKBOX.getXPath())); checkboxExternalRequirementMap = new HashMap<>(); webElements.forEach(webElement -> { final String dataTestsId = webElement.getAttribute("data-tests-id"); - checkboxExternalRequirementMap.put(dataTestsId.substring("checkbox-mark-as-external-".length()), webElement); + checkboxExternalRequirementMap.put(dataTestsId.substring("checkbox-external-req-".length()), webElement); }); } @@ -94,7 +94,8 @@ public class CompositionRequirementsCapabilitiesTab extends AbstractPageObject { private enum XpathSelector { REQ_CAPABILITIES_TAB("//req-capabilities-tab"), CAPABILITIES_ACCORDION("//div[@data-tests-id='Capabilities-accordion']"), - REQUIREMENTS_ACCORDION("//div[@data-tests-id='Requirements-accordion']"); + REQUIREMENTS_ACCORDION("//div[@data-tests-id='Requirements-accordion']"), + REQUIREMENT_EXTERNAL_CHECKBOX("//checkbox[starts-with(@data-tests-id, 'checkbox-external-req-')]"); private final String xPath; |