diff options
Diffstat (limited to 'catalog-be/src')
4 files changed, 629 insertions, 51 deletions
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 1f4eb539d6..e5e8486d94 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 @@ -1094,10 +1094,72 @@ public class ComponentInstanceBusinessLogic extends BaseBusinessLogic { } - public Either<RequirementCapabilityRelDef, ResponseFormat> dissociateRIFromRI(String componentId, String userId, RequirementCapabilityRelDef requirementDef, ComponentTypeEnum componentTypeEnum) { + /** + * @param componentId + * @param userId + * @param requirementDefList + * @param componentTypeEnum + * @return + */ + public List<RequirementCapabilityRelDef> batchDissociateRIFromRI( + String componentId, + String userId, + List<RequirementCapabilityRelDef> requirementDefList, + ComponentTypeEnum componentTypeEnum) { + + List<RequirementCapabilityRelDef> delOkResult = new ArrayList<>(); + Either<Component, ResponseFormat> validateResponse = validateDissociateRI(componentId, userId, componentTypeEnum); + if (validateResponse.isRight()) { + + return delOkResult; + } + Component containerComponent = validateResponse.left().value(); + Either<Boolean, ResponseFormat> lockComponent = lockComponent(containerComponent, "associateRIToRI"); + if (lockComponent.isRight()) { + return delOkResult; + } + try { + for (RequirementCapabilityRelDef requirementDef : requirementDefList) { + Either<RequirementCapabilityRelDef, ResponseFormat> actionResponse = dissociateRIFromRI( + componentId, requirementDef, containerComponent); + + if (actionResponse.isLeft()) { + delOkResult.add(actionResponse.left().value()); + } + } + } finally { + unlockComponent(validateResponse, containerComponent); + } + return delOkResult; + } + + public Either<RequirementCapabilityRelDef, ResponseFormat> dissociateRIFromRI( + String componentId, String userId, RequirementCapabilityRelDef requirementDef, ComponentTypeEnum componentTypeEnum) { + Either<Component, ResponseFormat> validateResponse = validateDissociateRI(componentId, userId, componentTypeEnum); + if(validateResponse.isRight()) + { + return Either.right(validateResponse.right().value()); + } + Either<RequirementCapabilityRelDef, ResponseFormat> actionResponse = null; + Component containerComponent = validateResponse.left().value(); + Either<Boolean, ResponseFormat> lockComponent = lockComponent(containerComponent, "associateRIToRI"); + if (lockComponent.isRight()) { + return Either.right(lockComponent.right().value()); + } + try { + actionResponse = dissociateRIFromRI( + componentId, requirementDef,containerComponent); + } finally { + unlockComponent(validateResponse, containerComponent); + } + return actionResponse; + } + + private Either<Component, ResponseFormat> validateDissociateRI( + String componentId, String userId, ComponentTypeEnum componentTypeEnum) { validateUserExists(userId, "dissociate RI From RI", false); - Either<RequirementCapabilityRelDef, ResponseFormat> resultOp = null; + Either<org.openecomp.sdc.be.model.Component, ResponseFormat> validateComponentExists = validateComponentExists(componentId, componentTypeEnum, null); if (validateComponentExists.isRight()) { return Either.right(validateComponentExists.right().value()); @@ -1108,45 +1170,49 @@ public class ComponentInstanceBusinessLogic extends BaseBusinessLogic { if (validateCanWorkOnComponent.isRight()) { return Either.right(validateCanWorkOnComponent.right().value()); } - Either<Boolean, ResponseFormat> lockComponent = lockComponent(containerComponent, "associateRIToRI"); + return Either.left(containerComponent); - if (lockComponent.isRight()) { - return Either.right(lockComponent.right().value()); - } - try { - log.debug("Try to create entry on graph"); - Either<RequirementCapabilityRelDef, StorageOperationStatus> result = toscaOperationFacade.dissociateResourceInstances(componentId, requirementDef); - if (result.isLeft()) { - log.debug("Enty on graph is created."); - RequirementCapabilityRelDef requirementCapabilityRelDef = result.left().value(); - resultOp = Either.left(requirementCapabilityRelDef); - return resultOp; + } + private Either<RequirementCapabilityRelDef, ResponseFormat> dissociateRIFromRI( + String componentId, RequirementCapabilityRelDef requirementDef, Component containerComponent) { - } else { + Either<RequirementCapabilityRelDef, ResponseFormat> resultOp = null; + log.debug("Try to create entry on graph"); + Either<RequirementCapabilityRelDef, StorageOperationStatus> result = toscaOperationFacade.dissociateResourceInstances( + componentId, requirementDef); + if (result.isLeft()) { + log.debug("Enty on graph is created."); + RequirementCapabilityRelDef requirementCapabilityRelDef = result.left().value(); + resultOp = Either.left(requirementCapabilityRelDef); + return resultOp; - log.debug("Failed to dissocaite node {} from node {}", requirementDef.getFromNode(), requirementDef.getToNode()); - String fromNameOrId = ""; - String toNameOrId = ""; - Either<ComponentInstance, StorageOperationStatus> fromResult = getResourceInstanceById(containerComponent, requirementDef.getFromNode()); - Either<ComponentInstance, StorageOperationStatus> toResult = getResourceInstanceById(containerComponent, requirementDef.getToNode()); + } else { - toNameOrId = requirementDef.getFromNode(); - fromNameOrId = requirementDef.getFromNode(); - if (fromResult.isLeft()) { - fromNameOrId = fromResult.left().value().getName(); - } - if (toResult.isLeft()) { - toNameOrId = toResult.left().value().getName(); - } + log.debug("Failed to dissocaite node {} from node {}", requirementDef.getFromNode(), requirementDef.getToNode()); + String fromNameOrId = ""; + String toNameOrId = ""; + Either<ComponentInstance, StorageOperationStatus> fromResult = getResourceInstanceById( + containerComponent, requirementDef.getFromNode()); + Either<ComponentInstance, StorageOperationStatus> toResult = getResourceInstanceById( + containerComponent, requirementDef.getToNode()); - resultOp = Either - .right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponseForResourceInstance(result.right().value(), true), fromNameOrId, toNameOrId, requirementDef.getRelationships().get(0).getRelation().getRequirement())); - return resultOp; + toNameOrId = requirementDef.getFromNode(); + fromNameOrId = requirementDef.getFromNode(); + if (fromResult.isLeft()) { + fromNameOrId = fromResult.left().value().getName(); } - } finally { - unlockComponent(resultOp, containerComponent); + if (toResult.isLeft()) { + toNameOrId = toResult.left().value().getName(); + } + + resultOp = Either + .right(componentsUtils.getResponseFormat( + componentsUtils.convertFromStorageResponseForResourceInstance( + result.right().value(), true), fromNameOrId, toNameOrId, requirementDef.getRelationships().get(0).getRelation().getRequirement())); + return resultOp; } } + /** * Allows to get relation contained in specified component according to received Id * @param componentId @@ -2820,7 +2886,7 @@ public class ComponentInstanceBusinessLogic extends BaseBusinessLogic { sourceAttribute.setUniqueId( UniqueIdBuilder.buildResourceInstanceUniuqeId( - "attribute" , destComponentInstanceId.split("\\.")[1] , sourceAttributeName)); + "attribute" , destComponentInstanceId.split("\\.")[1] , sourceAttributeName)); Either<ComponentInstanceProperty, ResponseFormat> updateAttributeValueEither = createOrUpdateAttributeValueForCopyPaste(ComponentTypeEnum.SERVICE, @@ -2989,4 +3055,97 @@ public class ComponentInstanceBusinessLogic extends BaseBusinessLogic { return Either.right(componentsUtils.getResponseFormat( ActionStatus.USER_DEFINED, "Failed to paste component instance to the canvas")); } + + /** + * Method to delete selected nodes and edges on composition page + * @param containerComponentType + * @param componentId + * @param componentInstanceIdList + * @param userId + * @return + */ + public Map<String, List<String>> batchDeleteComponentInstance(String containerComponentType, + String componentId, + List<String> componentInstanceIdList, + String userId) { + + List<String> deleteErrorIds = new ArrayList<>(); + Map<String, List<String>> deleteErrorMap = new HashMap<>(); + Either<Component, ResponseFormat> validateResponse = validateUser(containerComponentType, componentId, userId); + if (validateResponse.isRight()) { + deleteErrorMap.put("deleteFailedIds", componentInstanceIdList); + return deleteErrorMap; + } + Component containerComponent = validateResponse.left().value(); + + Either<Boolean, ResponseFormat> lockComponent = lockComponent( + containerComponent, "batchDeleteComponentInstance"); + if (lockComponent.isRight()) { + log.error("Failed to lockComponent containerComponent"); + deleteErrorMap.put("deleteFailedIds", componentInstanceIdList); + return deleteErrorMap; + } + + try { + for (String eachInstanceId : componentInstanceIdList) { + Either<ComponentInstance, ResponseFormat> actionResponse = batchDeleteComponentInstance( + containerComponent, containerComponentType, componentId, eachInstanceId); + log.debug("batchDeleteResourceInstances actionResponse is {}", actionResponse); + if (actionResponse.isRight()) { + log.error("Failed to delete ComponentInstance [{}]", eachInstanceId); + deleteErrorIds.add(eachInstanceId); + } + } + //sending the ids of the error nodes that were not deleted to UI + deleteErrorMap.put("deleteFailedIds", deleteErrorIds); + return deleteErrorMap; + } finally { + unlockComponent(validateResponse, containerComponent); + } + } + + private Either<Component, ResponseFormat> validateUser(String containerComponentParam, + String containerComponentId, + String userId) { + validateUserExists(userId, "delete Component Instance", false); + Either<ComponentTypeEnum, ResponseFormat> validateComponentType = validateComponentType(containerComponentParam); + if (validateComponentType.isRight()) { + log.error("ComponentType[{}] doesn't support", containerComponentParam); + return Either.right(validateComponentType.right().value()); + } + + final ComponentTypeEnum containerComponentType = validateComponentType.left().value(); + Either<Component, ResponseFormat> validateComponentExists = validateComponentExists( + containerComponentId, containerComponentType, null); + if (validateComponentExists.isRight()) { + log.error("Component Id[{}] doesn't exist", containerComponentId); + return Either.right(validateComponentExists.right().value()); + } + + Component containerComponent = validateComponentExists.left().value(); + Either<Boolean, ResponseFormat> validateCanWorkOnComponent = validateCanWorkOnComponent(containerComponent, userId); + if (validateCanWorkOnComponent.isRight()) { + return Either.right(validateCanWorkOnComponent.right().value()); + } + return Either.left(containerComponent); + } + + private Either<ComponentInstance, ResponseFormat> batchDeleteComponentInstance(Component containerComponent, + String containerComponentType, + String containerComponentId, + String componentInstanceId) { + + Either<ComponentInstance, ResponseFormat> resultOp; + final ComponentTypeEnum containerComponentTypeEnum = ComponentTypeEnum.findByParamName(containerComponentType); + + resultOp = deleteComponentInstance(containerComponent, componentInstanceId, containerComponentTypeEnum); + + if (resultOp.isRight()) { + log.error("Failed to deleteComponentInstance with instanceId[{}]", componentInstanceId); + return Either.right(resultOp.right().value()); + } + + log.info("Successfully deleted instance with id {}", componentInstanceId); + return Either.left(resultOp.left().value()); + } } 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 3195727a68..042303e2c3 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 @@ -1244,9 +1244,138 @@ public class ComponentInstanceServlet extends AbstractValidationsServlet { return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), copyComponentInstance.left().value()); } catch (Exception e) { - log.error("Failed to convert json to Map { }, error: { }", data, e); + log.error("Failed to convert json to Map { }", data, e); return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.USER_DEFINED, "Failed to get the copied component instance information")); } } + + @POST + @Path("/{containerComponentType}/{componentId}/batchDeleteResourceInstances/") + @Consumes(MediaType.APPLICATION_JSON) + @Produces(MediaType.APPLICATION_JSON) + @ApiOperation(value = "Batch Delete ResourceInstances", httpMethod = "POST") + @ApiResponses(value = { + @ApiResponse(code = 203, message = "ResourceInstances deleted"), + @ApiResponse(code = 403, message = "Restricted Operation"), + @ApiResponse(code = 400, message = "Invalid Content / Missing Content") + }) + public Response batchDeleteResourceInstances( + @ApiParam(value = "valid values: resources / services / products", allowableValues = ComponentTypeEnum.RESOURCE_PARAM_NAME + "," + ComponentTypeEnum.SERVICE_PARAM_NAME + "," + + ComponentTypeEnum.PRODUCT_PARAM_NAME) + @PathParam("containerComponentType") final String containerComponentType, + @PathParam("componentId") final String componentId, + @Context final HttpServletRequest request, + @ApiParam(value = "Component Instance Id List", required = true) final String componentInstanceIdLisStr) { + ServletContext context = request.getSession().getServletContext(); + try { + if (componentInstanceIdLisStr == null || componentInstanceIdLisStr.isEmpty()) { + log.error("Empty JSON List was sent",componentInstanceIdLisStr); + return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.INVALID_CONTENT)); + } + + + ComponentInstanceBusinessLogic componentInstanceLogic = getComponentInstanceBL(context); + if (componentInstanceLogic == null) { + log.error("Unsupported component type {}", containerComponentType); + return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.UNSUPPORTED_ERROR, containerComponentType)); + } + + Either<List<String>, ResponseFormat> convertResponse = convertToStringList(componentInstanceIdLisStr); + + if (convertResponse.isRight()) { + BeEcompErrorManager.getInstance().logBeSystemError("Resource Instance - batchDeleteResourceInstances"); + log.error("Failed to convert received data to BE format."); + return buildErrorResponse(convertResponse.right().value()); + } + + String userId = request.getHeader(Constants.USER_ID_HEADER); + List<String> componentInstanceIdList = convertResponse.left().value(); + log.debug("batchDeleteResourceInstances componentInstanceIdList is {}", componentInstanceIdList); + Map<String, List<String>> deleteErrorMap = componentInstanceLogic.batchDeleteComponentInstance(containerComponentType, + componentId, componentInstanceIdList, userId); + + return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), deleteErrorMap); + } catch (Exception e) { + BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Batch Delete ResourceInstances"); + log.error("batch delete resource instances with exception" , e); + return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR)); + } + + } + + @PUT + @Path("/{containerComponentType}/{componentId}/resourceInstance/batchDissociate") + @Consumes(MediaType.APPLICATION_JSON) + @Produces(MediaType.APPLICATION_JSON) + @ApiOperation(value = "Batch Dissociate RI from RI", httpMethod = "PUT", notes = "Returns deleted RelationShip Info", response = Response.class) + @ApiResponses(value = { + @ApiResponse(code = 201, message = "Relationship deleted"), + @ApiResponse(code = 403, message = "Missing Information"), + @ApiResponse(code = 400, message = "Invalid Content / Missing Content") + }) + public Response batchDissociateRIFromRI( + @ApiParam(value = "allowed values are resources/services/products", allowableValues = ComponentTypeEnum.RESOURCE_PARAM_NAME + "," + ComponentTypeEnum.SERVICE_PARAM_NAME + "," + ComponentTypeEnum.PRODUCT_PARAM_NAME, required = true) + @PathParam("containerComponentType") final String containerComponentType, + @ApiParam(value = "unique id of the container component") + @PathParam("componentId") final String componentId, + @HeaderParam(value = Constants.USER_ID_HEADER) String userId, + @ApiParam(value = "RelationshipInfo", required = true) String data, + @Context final HttpServletRequest request) { + ServletContext context = request.getSession().getServletContext(); + + try { + if (data == null || data.length() == 0) { + log.info("Empty JSON list was sent"); + return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.INVALID_CONTENT)); + } + + ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.findByParamName(containerComponentType); + ComponentInstanceBusinessLogic componentInstanceLogic = getComponentInstanceBL(context); + + if (componentInstanceLogic == null) { + log.debug("Unsupported component type {}", containerComponentType); + return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.UNSUPPORTED_ERROR, containerComponentType)); + } + + Either<List<RequirementCapabilityRelDef>, ResponseFormat> regInfoWs = convertToRequirementCapabilityRelDefList(data); + + if (regInfoWs.isRight()) { + BeEcompErrorManager.getInstance().logBeSystemError("Resource Instance - batch dissociateRIFromRI"); + log.debug("Failed to convert received data to BE format"); + return buildErrorResponse(regInfoWs.right().value()); + } + + List<RequirementCapabilityRelDef> requirementDefList = regInfoWs.left().value(); + List<RequirementCapabilityRelDef> delOkResult = componentInstanceLogic.batchDissociateRIFromRI( + componentId, userId, requirementDefList, componentTypeEnum); + + return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), delOkResult); + } catch (Exception e) { + BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Batch Dissociate Resource Instance"); + log.debug("batch dissociate resource instance from service failed with exception", e); + return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR)); + } + } + + private Either<List<String>, ResponseFormat> convertToStringList(String datalist) { + Either<String[], ResponseFormat> convertStatus = getComponentsUtils().convertJsonToObjectUsingObjectMapper(datalist, new User(), String[].class, null, null); + + if (convertStatus.isRight()) { + return Either.right(convertStatus.right().value()); + } + + return Either.left(Arrays.asList(convertStatus.left().value())); + } + + private Either<List<RequirementCapabilityRelDef>, ResponseFormat> convertToRequirementCapabilityRelDefList(String data) { + Either<RequirementCapabilityRelDef[], ResponseFormat> convertStatus = getComponentsUtils().convertJsonToObjectUsingObjectMapper(data, new User(), RequirementCapabilityRelDef[].class, null, null); + + if (convertStatus.isRight()) { + return Either.right(convertStatus.right().value()); + } + + return Either.left(Arrays.asList(convertStatus.left().value())); + } + } 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 929bb97281..b5d937e0e8 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 @@ -1,3 +1,22 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ package org.openecomp.sdc.be.components.impl; import static org.assertj.core.api.Assertions.assertThat; @@ -47,12 +66,10 @@ import static org.junit.Assert.assertSame; import static org.junit.Assert.assertEquals; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anySet; -import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.when; import static org.mockito.ArgumentMatchers.*; -import static org.mockito.Mockito.when; /** * The test suite designed for test functionality of ComponentInstanceBusinessLogic class @@ -98,7 +115,7 @@ public class ComponentInstanceBusinessLogicTest { private ArtifactsBusinessLogic artifactBusinessLogic; @Mock private GraphLockOperation graphLockOperation; - + private Component service; private Component resource; private ComponentInstance toInstance; @@ -170,7 +187,7 @@ public class ComponentInstanceBusinessLogicTest { when(toscaOperationFacade.getToscaFullElement(eq(new_Comp_UID))).thenReturn(Either.left(component2)); Either<Set<String>, ResponseFormat> resultOp = componentInstanceBusinessLogic.forwardingPathOnVersionChange - (containerComponentParam,containerComponentID,componentInstanceID,newComponentInstance); + (containerComponentParam,containerComponentID,componentInstanceID,newComponentInstance); assertEquals(1,resultOp.left().value().size()); assertEquals("FP-ID-1",resultOp.left().value().iterator().next()); @@ -185,7 +202,7 @@ public class ComponentInstanceBusinessLogicTest { String componentInstanceID = "NodeA1"; Service component = new Service(); component.setComponentInstances(Arrays.asList(createComponentIstance("NodeA2"),createComponentIstance("NodeB2"), - createComponentIstance(componentInstanceID))); + createComponentIstance(componentInstanceID))); component.addForwardingPath(createPath("path1", componentInstanceID, "NodeB1", "1")); component.addForwardingPath(createPath("Path2", "NodeA2","NodeB2", "2")); @@ -195,7 +212,7 @@ public class ComponentInstanceBusinessLogicTest { final ComponentInstance ci = new ComponentInstance(); ci.setName(componentInstanceID); Either<ComponentInstance, ResponseFormat> responseFormatEither = componentInstanceBusinessLogic.deleteForwardingPathsRelatedTobeDeletedComponentInstance( - containerComponentID, containerComponentType, Either.left(ci)); + containerComponentID, containerComponentType, Either.left(ci)); assertThat(responseFormatEither.isLeft()).isEqualTo(true); } @@ -228,18 +245,18 @@ public class ComponentInstanceBusinessLogicTest { forwardingPath.setDestinationPortNumber("DestinationPortNumber"); forwardingPath.setUniqueId("FP-ID-1"); ListDataDefinition<ForwardingPathElementDataDefinition> forwardingPathElementListDataDefinition = - new ListDataDefinition<>(); + new ListDataDefinition<>(); forwardingPathElementListDataDefinition.add( - new ForwardingPathElementDataDefinition(componentInstanceID, "nodeB", "nodeA_FORWARDER_CAPABILITY", - "nodeBcpType" , "nodeDcpName", - "nodeBcpName")); + new ForwardingPathElementDataDefinition(componentInstanceID, "nodeB", "nodeA_FORWARDER_CAPABILITY", + "nodeBcpType" , "nodeDcpName", + "nodeBcpName")); forwardingPath.setPathElements(forwardingPathElementListDataDefinition); Map<String, ForwardingPathDataDefinition> forwardingPaths = new HashMap<>(); forwardingPaths.put("1122", forwardingPath); return forwardingPaths; } - @SuppressWarnings("unchecked") + @SuppressWarnings("unchecked") private void getServiceRelationByIdSuccess(Component component){ Either<Component, StorageOperationStatus> getComponentRes = Either.left(component); when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))).thenReturn(getComponentRes); @@ -534,8 +551,8 @@ public class ComponentInstanceBusinessLogicTest { } @Ignore("test failing skipping for now") - @Test - public void testCreateComponentInstanceOnGraph2() { + @Test + public void testCreateComponentInstanceOnGraph2() { ComponentInstanceBusinessLogic testSubject; createResource(); resource.setName("name"); @@ -552,7 +569,7 @@ public class ComponentInstanceBusinessLogicTest { // default test testSubject=createTestSubject(); result=Deencapsulation.invoke(testSubject, "createComponentInstanceOnGraph", new Object[]{resource, resource, toInstance, user}); - } + } @Test public void testUpdateComponentInstanceMetadata() { @@ -1174,7 +1191,7 @@ public class ComponentInstanceBusinessLogicTest { when(toscaOperationFacade .addInformationalArtifactsToInstance(eq(resource.getUniqueId()), eq(inputComponentInstance), isNull(Map.class))).thenReturn(artStatus); - + result = componentInstanceBusinessLogic .copyComponentInstance(inputComponentInstance, containerComponentId, componentInstanceId, USER_ID); @@ -1269,6 +1286,169 @@ public class ComponentInstanceBusinessLogicTest { assertEquals(result.left().value(), defaultValue); } + @Test + public void testBatchDeleteComponentInstanceFailureWrongType() { + Map<String, List<String>> result; + List<String> componentInstanceIdList = new ArrayList<>(); + String containerComponentParam = "WRONG_TYPE"; + String containerComponentId = "containerComponentId"; + String componentInstanceId = "componentInstanceId"; + componentInstanceIdList.add(componentInstanceId); + String userId = USER_ID; + Map<String, List<String>> deleteErrorMap = new HashMap<>(); + List<String> deleteErrorIds = new ArrayList<>(); + deleteErrorIds.add(componentInstanceId); + deleteErrorMap.put("deleteFailedIds", deleteErrorIds); + + result = componentInstanceBusinessLogic + .batchDeleteComponentInstance(containerComponentParam, containerComponentId, componentInstanceIdList, + userId); + + assertEquals(deleteErrorMap, result); + } + + @Test + public void testBatchDeleteComponentInstanceFailureCompIds() { + Map<String, List<String>> result; + String containerComponentParam = ComponentTypeEnum.SERVICE_PARAM_NAME; + String containerComponentId = "containerComponentId"; + String componentInstanceId = "componentInstanceId"; + List<String> componentInstanceIdList = new ArrayList<>(); + componentInstanceIdList.add(componentInstanceId); + String userId = USER_ID; + Map<String, List<String>> deleteErrorMap = new HashMap<>(); + List<String> deleteErrorIds = new ArrayList<>(); + deleteErrorIds.add(componentInstanceId); + deleteErrorMap.put("deleteFailedIds", deleteErrorIds); + + Either<Component, StorageOperationStatus> err = Either.right(StorageOperationStatus.GENERAL_ERROR); + when(toscaOperationFacade.getToscaElement(eq(containerComponentId), any(ComponentParametersView.class))) + .thenReturn(err); + + result = componentInstanceBusinessLogic + .batchDeleteComponentInstance(containerComponentParam, containerComponentId, componentInstanceIdList, + userId); + + assertEquals(deleteErrorMap, result); + } + + @Test + public void testBatchDeleteComponentInstanceSuccess() { + Map<String, List<String>> result; + String containerComponentParam = ComponentTypeEnum.SERVICE_PARAM_NAME; + LifecycleStateEnum oldLifeCycleState = service.getLifecycleState(); + String oldLastUpdatedUserId = service.getLastUpdaterUserId(); + service.setLastUpdaterUserId(USER_ID); + service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); + String containerComponentId = service.getUniqueId(); + String componentInstanceId = TO_INSTANCE_ID; + String userId = USER_ID; + List<String> componentInstanceIdList = new ArrayList<>(); + componentInstanceIdList.add(componentInstanceId); + Map<String, List<String>> deleteErrorMap = new HashMap<>(); + List<String> deleteErrorIds = new ArrayList<>(); + deleteErrorMap.put("deleteFailedIds", deleteErrorIds); + + Either<Component, StorageOperationStatus> cont = Either.left(service); + when(graphLockOperation.unlockComponent(Mockito.anyString(), eq(NodeTypeEnum.Service))) + .thenReturn(StorageOperationStatus.OK); + when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Service))) + .thenReturn(StorageOperationStatus.OK); + ImmutablePair<Component, String> pair = new ImmutablePair<>(resource, TO_INSTANCE_ID); + Either<ImmutablePair<Component, String>, StorageOperationStatus> result2 = Either.left(pair); + when(toscaOperationFacade.deleteComponentInstanceFromTopologyTemplate(service, componentInstanceId)) + .thenReturn(result2); + when(toscaOperationFacade.getToscaElement(eq(service.getUniqueId()), any(ComponentParametersView.class))) + .thenReturn(cont); + when(titanDao.commit()).thenReturn(TitanOperationStatus.OK); + + result = componentInstanceBusinessLogic + .batchDeleteComponentInstance(containerComponentParam, containerComponentId, componentInstanceIdList, userId); + + service.setLastUpdaterUserId(oldLastUpdatedUserId); + service.setLifecycleState(oldLifeCycleState); + assertEquals(deleteErrorMap,result); + } + + @Test + public void testDissociateRIFromRIFailDissociate() { + + List<RequirementCapabilityRelDef> result; + RequirementCapabilityRelDef ref = new RequirementCapabilityRelDef(); + ref.setFromNode(FROM_INSTANCE_ID); + ref.setToNode(TO_INSTANCE_ID); + List<CapabilityRequirementRelationship> relationships = new ArrayList<>(); + CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship(); + RelationshipInfo ri = new RelationshipInfo(); + ri.setRequirement(REQUIREMENT_NAME); + relationship.setRelation(ri); + relationships.add(relationship); + ref.setRelationships(relationships); + List<RequirementCapabilityRelDef> requirementDefList = new ArrayList<>(); + requirementDefList.add(ref); + ComponentTypeEnum componentTypeEnum = service.getComponentType(); + String componentId = service.getUniqueId(); + String userId = USER_ID; + LifecycleStateEnum oldLifeCycleState = service.getLifecycleState(); + String oldLastUpdatedUserId = service.getLastUpdaterUserId(); + service.setLastUpdaterUserId(USER_ID); + service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); + + Either<Component, StorageOperationStatus> cont = Either.left(service); + when(toscaOperationFacade.getToscaElement(eq(service.getUniqueId()), any(ComponentParametersView.class))) + .thenReturn(cont); + when(graphLockOperation.unlockComponent(Mockito.anyString(), eq(NodeTypeEnum.Service))) + .thenReturn(StorageOperationStatus.OK); + when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Service))) + .thenReturn(StorageOperationStatus.OK); + Either<RequirementCapabilityRelDef, StorageOperationStatus> resultEither; + resultEither = Either.right(StorageOperationStatus.OK); + when(toscaOperationFacade.dissociateResourceInstances(componentId, ref)).thenReturn(resultEither); + + result = componentInstanceBusinessLogic + .batchDissociateRIFromRI(componentId, userId, requirementDefList, componentTypeEnum); + + service.setLastUpdaterUserId(oldLastUpdatedUserId); + service.setLifecycleState(oldLifeCycleState); + + assertEquals(new ArrayList<>(), result); + } + + @Test + public void testDissociateRIFromRISuccess() { + + List<RequirementCapabilityRelDef> result; + RequirementCapabilityRelDef ref = new RequirementCapabilityRelDef(); + List<RequirementCapabilityRelDef> requirementDefList = new ArrayList<>(); + requirementDefList.add(ref); + ComponentTypeEnum componentTypeEnum = service.getComponentType(); + String componentId = service.getUniqueId(); + String userId = USER_ID; + LifecycleStateEnum oldLifeCycleState = service.getLifecycleState(); + String oldLastUpdatedUserId = service.getLastUpdaterUserId(); + service.setLastUpdaterUserId(USER_ID); + service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); + + Either<Component, StorageOperationStatus> cont = Either.left(service); + when(toscaOperationFacade.getToscaElement(eq(service.getUniqueId()), any(ComponentParametersView.class))) + .thenReturn(cont); + when(graphLockOperation.unlockComponent(Mockito.anyString(), eq(NodeTypeEnum.Service))) + .thenReturn(StorageOperationStatus.OK); + when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Service))) + .thenReturn(StorageOperationStatus.OK); + Either<RequirementCapabilityRelDef, StorageOperationStatus> resultEither; + resultEither = Either.left(ref); + when(toscaOperationFacade.dissociateResourceInstances(componentId, ref)).thenReturn(resultEither); + + result = componentInstanceBusinessLogic + .batchDissociateRIFromRI(componentId, userId, requirementDefList, componentTypeEnum); + + service.setLastUpdaterUserId(oldLastUpdatedUserId); + service.setLifecycleState(oldLifeCycleState); + + assertEquals(requirementDefList, result); + } + private ComponentInstance createComponetInstanceFromComponent(Component component) { ComponentInstance componentInst = new ComponentInstance(); componentInst.setUniqueId(component.getUniqueId()); diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/servlets/ComponentInstanceServletTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/servlets/ComponentInstanceServletTest.java index d8e7896d71..7d05c697d5 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/servlets/ComponentInstanceServletTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/servlets/ComponentInstanceServletTest.java @@ -4,6 +4,7 @@ import fj.data.Either; import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.ArrayList; import javax.ws.rs.client.Entity; import org.eclipse.jetty.http.HttpStatus; import org.glassfish.hk2.utilities.binding.AbstractBinder; @@ -12,6 +13,7 @@ import org.glassfish.jersey.test.JerseyTest; import org.glassfish.jersey.test.TestProperties; import org.junit.BeforeClass; import org.junit.Test; +import org.mockito.ArgumentMatchers; import org.mockito.Mockito; import org.openecomp.sdc.be.components.impl.ComponentInstanceBusinessLogic; import org.openecomp.sdc.be.config.SpringConfig; @@ -29,6 +31,8 @@ import org.openecomp.sdc.exception.ResponseFormat; import org.springframework.context.ApplicationContext; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.web.context.WebApplicationContext; +import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum; +import org.openecomp.sdc.be.model.User; import javax.servlet.ServletContext; import javax.servlet.http.HttpServletRequest; @@ -37,10 +41,11 @@ import javax.ws.rs.core.MediaType; import javax.ws.rs.core.Response; import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.when; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.nullable; /** * The test suite designed for test functionality of ComponentInstanceServlet class @@ -132,6 +137,111 @@ public class ComponentInstanceServletTest extends JerseyTest { assertEquals(response.getStatus(), HttpStatus.OK_200); } + @Test + public void testBatchDeleteResourceInstancesSuccess() { + + String componentId = "componentId"; + String containerComponentType = ComponentTypeEnum.SERVICE_PARAM_NAME; + String compId1 = "compId1"; + String[] delCompIds = new String[1]; + delCompIds[0] = compId1; + List<ComponentInstance> compInsts = new ArrayList<ComponentInstance>(); + String path = "/v1/catalog/" + containerComponentType + "/" + componentId + "/batchDeleteResourceInstances"; + + ComponentInstance compInst = new ComponentInstance(); + compInst.setName(compId1); + compInst.setUniqueId(compId1); + compInst.setComponentUid(compId1); + compInst.setInvariantName(compId1); + compInsts.add(compInst); + + when(responseFormat.getStatus()).thenReturn(HttpStatus.OK_200); + when(componentsUtils.getResponseFormat(ActionStatus.OK)).thenReturn(responseFormat); + Either<String[], ResponseFormat> convertStatusEither = Either.left(delCompIds); + when(componentsUtils + .convertJsonToObjectUsingObjectMapper(anyString(), any(User.class), ArgumentMatchers.<Class<String[]>>any(), + nullable(AuditingActionEnum.class), nullable(ComponentTypeEnum.class))).thenReturn(convertStatusEither); + when(componentInstanceBusinessLogic + .batchDeleteComponentInstance(eq(containerComponentType), eq(componentId), any(List.class), + eq(USER_ID))).thenReturn(Mockito.mock(Map.class)); + + Response response = target() + .path(path) + .request(MediaType.APPLICATION_JSON) + .header("USER_ID", USER_ID) + .post(Entity.json(compInsts)); + + assertEquals(HttpStatus.OK_200, response.getStatus()); + } + + @Test + public void testBatchDeleteResourceInstancesFailure() { + + String componentId = "componentId"; + String containerComponentType = ComponentTypeEnum.SERVICE_PARAM_NAME; + String path = "/v1/catalog/" + containerComponentType + "/" + componentId + "/batchDeleteResourceInstances"; + + when(responseFormat.getStatus()).thenReturn(HttpStatus.INTERNAL_SERVER_ERROR_500); + when(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT)).thenReturn(responseFormat); + + Response response = target() + .path(path) + .request(MediaType.APPLICATION_JSON) + .header("USER_ID", USER_ID) + .post(Entity.json("")); + + assertEquals(HttpStatus.INTERNAL_SERVER_ERROR_500, response.getStatus()); + } + + @Test + public void testBatchDissociateRIFromRISuccess() { + + String componentId = "componentId"; + String containerComponentType = ComponentTypeEnum.SERVICE_PARAM_NAME; + String path = "/v1/catalog/" + containerComponentType + "/" + componentId + "/resourceInstance/batchDissociate"; + RequirementCapabilityRelDef[] refs = new RequirementCapabilityRelDef[1]; + RequirementCapabilityRelDef ref = new RequirementCapabilityRelDef(); + refs[0] = ref; + + when(responseFormat.getStatus()).thenReturn(HttpStatus.OK_200); + when(componentsUtils.getResponseFormat(ActionStatus.OK)).thenReturn(responseFormat); + Either<RequirementCapabilityRelDef[], ResponseFormat> convertReqEither = Either.left(refs); + when(componentsUtils.convertJsonToObjectUsingObjectMapper(anyString(), any(User.class), + ArgumentMatchers.<Class<RequirementCapabilityRelDef[]>>any(), + nullable(AuditingActionEnum.class), nullable(ComponentTypeEnum.class))).thenReturn(convertReqEither); + Either<RequirementCapabilityRelDef, ResponseFormat> actionResponseEither = Either.left(ref); + when(componentInstanceBusinessLogic + .dissociateRIFromRI(componentId, USER_ID, ref, ComponentTypeEnum.findByParamName(containerComponentType))) + .thenReturn(actionResponseEither); + + Response response = target() + .path(path) + .request(MediaType.APPLICATION_JSON) + .header("USER_ID", USER_ID) + .put(Entity.json(refs)); + + assertEquals(HttpStatus.OK_200, response.getStatus()); + } + + @Test + public void testBatchDissociateRIFromRIFailure() { + + String componentId = "componentId"; + String containerComponentType = ComponentTypeEnum.SERVICE_PARAM_NAME; + String path = "/v1/catalog/" + containerComponentType + "/" + componentId + "/resourceInstance/batchDissociate"; + + when(responseFormat.getStatus()).thenReturn(HttpStatus.INTERNAL_SERVER_ERROR_500); + when(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT)).thenReturn(responseFormat); + + Response response = target() + .path(path) + .request(MediaType.APPLICATION_JSON) + .header("USER_ID", USER_ID) + .put(Entity.json("")); + + assertEquals(HttpStatus.INTERNAL_SERVER_ERROR_500, response.getStatus()); + } + @Override protected ResourceConfig configure() { forceSet(TestProperties.CONTAINER_PORT, "0"); |