aboutsummaryrefslogtreecommitdiffstats
path: root/catalog-be
diff options
context:
space:
mode:
Diffstat (limited to 'catalog-be')
-rw-r--r--catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ComponentInstanceBusinessLogic.java227
-rw-r--r--catalog-be/src/main/java/org/openecomp/sdc/be/servlets/ComponentInstanceServlet.java131
-rw-r--r--catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ComponentInstanceBusinessLogicTest.java210
-rw-r--r--catalog-be/src/test/java/org/openecomp/sdc/be/servlets/ComponentInstanceServletTest.java112
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");