/*- * ============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; 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.DynamicTest.dynamicTest; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anySet; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import fj.data.Either; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Optional; import java.util.Set; import mockit.Deencapsulation; import org.apache.commons.lang3.tuple.ImmutablePair; import org.apache.commons.lang3.tuple.Pair; import org.assertj.core.util.Lists; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DynamicTest; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.TestFactory; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.MockitoAnnotations; import org.mockito.junit.jupiter.MockitoExtension; import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException; import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException; import org.openecomp.sdc.be.components.impl.exceptions.ComponentException; import org.openecomp.sdc.be.components.validation.UserValidations; 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.JanusGraphDao; import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; import org.openecomp.sdc.be.datamodel.utils.ContainerInstanceTypesData; import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition; import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition; import org.openecomp.sdc.be.datatypes.elements.ForwardingPathElementDataDefinition; 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.impl.ComponentsUtils; 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.ComponentInstanceInput; import org.openecomp.sdc.be.model.ComponentInstancePropInput; import org.openecomp.sdc.be.model.ComponentInstanceProperty; import org.openecomp.sdc.be.model.ComponentParametersView; import org.openecomp.sdc.be.model.DataTypeDefinition; import org.openecomp.sdc.be.model.InputDefinition; import org.openecomp.sdc.be.model.LifecycleStateEnum; import org.openecomp.sdc.be.model.PolicyDefinition; 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.RequirementDefinition; import org.openecomp.sdc.be.model.Resource; import org.openecomp.sdc.be.model.Service; import org.openecomp.sdc.be.model.User; import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache; import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ForwardingPathOperation; import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade; 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; import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum; import org.openecomp.sdc.common.api.ArtifactTypeEnum; import org.openecomp.sdc.common.api.ConfigurationSource; import org.openecomp.sdc.common.impl.ExternalConfiguration; import org.openecomp.sdc.common.impl.FSConfigurationSource; import org.openecomp.sdc.common.util.ValidationUtils; import org.openecomp.sdc.exception.ResponseFormat; /** * The test suite designed for test functionality of ComponentInstanceBusinessLogic class */ @ExtendWith(MockitoExtension.class) class ComponentInstanceBusinessLogicTest { private final static String USER_ID = "jh0003"; private final static String COMPONENT_ID = "componentId"; private final static String ORIGIN_COMPONENT_ID = "originComponentId"; private final static String ORIGIN_COMPONENT_VERSION = "1.0"; private final static String TO_INSTANCE_ID = "toInstanceId"; private final static String TO_INSTANCE_NAME = "toInstanceName"; private final static String COMPONENT_INSTANCE_ID = "componentInstanceId"; private final static String COMPONENT_INSTANCE_NAME = "componentInstanceName"; private final static String FROM_INSTANCE_ID = "fromInstanceId"; private final static String RELATION_ID = "relationId"; private final static String CAPABILITY_OWNER_ID = "capabilityOwnerId"; private final static String CAPABILITY_UID = "capabilityUid"; private final static String CAPABILITY_NAME = "capabilityName"; private final static String REQUIREMENT_OWNER_ID = "requirementOwnerId"; private final static String REQUIREMENT_UID = "requirementUid"; private final static String REQUIREMENT_NAME = "requirementName"; private final static String RELATIONSHIP_TYPE = "relationshipType"; private final static String ARTIFACT_1 = "cloudtech_k8s_charts.zip"; private final static String ARTIFACT_2 = "cloudtech_azure_day0.zip"; private final static String ARTIFACT_3 = "cloudtech_aws_configtemplate.zip"; private final static String ARTIFACT_4 = "k8s_charts.zip"; private final static String ARTIFACT_5 = "cloudtech_openstack_configtemplate.zip"; private final static String PROP_NAME = "propName"; private final static String NON_EXIST_NAME = "nonExistName"; private final static String INPUT_ID = "inputId"; private final static String ICON_NAME = "icon"; private static ConfigurationSource configurationSource = new FSConfigurationSource( ExternalConfiguration.getChangeListener(), "src/test/resources/config/catalog-be"); private static ConfigurationManager configurationManager = new ConfigurationManager(configurationSource); @InjectMocks private static ComponentInstanceBusinessLogic componentInstanceBusinessLogic; @Mock private ComponentInstancePropInput componentInstancePropInput; @Mock private ArtifactsBusinessLogic artifactsBusinessLogic; @Mock private ComponentsUtils componentsUtils; @Mock private ToscaOperationFacade toscaOperationFacade; @Mock private ForwardingPathOperation forwardingPathOperation; @Mock private User user; @Mock private UserValidations userValidations; @Mock private GraphLockOperation graphLockOperation; @Mock private JanusGraphDao janusGraphDao; @Mock private ApplicationDataTypeCache dataTypeCache; @Mock private PropertyOperation propertyOperation; @Mock private ContainerInstanceTypesData containerInstanceTypeData; @Mock private CompositionBusinessLogic compositionBusinessLogic; private Component service; private Component resource; private ComponentInstance toInstance; private ComponentInstance fromInstance; private RequirementCapabilityRelDef relation; private List ciPropertyList; private List ciInputList; @BeforeEach void init() { MockitoAnnotations.initMocks(this); stubMethods(); createComponents(); } @Test void testGetRelationByIdSuccess() { getServiceRelationByIdSuccess(service); getServiceRelationByIdSuccess(resource); } @Test void testGetRelationByIdUserValidationFailure() { getServiceRelationByIdUserValidationFailure(service); getServiceRelationByIdUserValidationFailure(resource); } @Test void testGetRelationByIdComponentNotFoundFailure() { getRelationByIdComponentNotFoundFailure(service); getRelationByIdComponentNotFoundFailure(resource); } @Test void testForwardingPathOnVersionChange() { getforwardingPathOnVersionChange(); } @Test void testIsCloudSpecificArtifact() { assertThat(componentInstanceBusinessLogic.isCloudSpecificArtifact(ARTIFACT_1)).isTrue(); assertThat(componentInstanceBusinessLogic.isCloudSpecificArtifact(ARTIFACT_2)).isTrue(); assertThat(componentInstanceBusinessLogic.isCloudSpecificArtifact(ARTIFACT_3)).isTrue(); assertThat(componentInstanceBusinessLogic.isCloudSpecificArtifact(ARTIFACT_4)).isFalse(); assertThat(componentInstanceBusinessLogic.isCloudSpecificArtifact(ARTIFACT_5)).isFalse(); } private void getforwardingPathOnVersionChange() { String containerComponentParam = "services"; String containerComponentID = "121-cont"; String componentInstanceID = "121-cont-1-comp"; Service component = new Service(); Map forwardingPaths = generateForwardingPath(componentInstanceID); //Add existing componentInstance to component List componentInstanceList = new ArrayList<>(); ComponentInstance oldComponentInstance = new ComponentInstance(); oldComponentInstance.setName("OLD_COMP_INSTANCE"); oldComponentInstance.setUniqueId(componentInstanceID); oldComponentInstance.setName(componentInstanceID); oldComponentInstance.setToscaPresentationValue(JsonPresentationFields.CI_COMPONENT_UID, "1-comp"); componentInstanceList.add(oldComponentInstance); component.setComponentInstances(componentInstanceList); component.setForwardingPaths(forwardingPaths); List componentInstanceListNew = new ArrayList<>(); ComponentInstance newComponentInstance = new ComponentInstance(); String new_Comp_UID = "2-comp"; newComponentInstance.setToscaPresentationValue(JsonPresentationFields.CI_COMPONENT_UID, new_Comp_UID); newComponentInstance.setUniqueId(new_Comp_UID); componentInstanceListNew.add(newComponentInstance); Component component2 = new Service(); component2.setComponentInstances(componentInstanceListNew); //Mock for getting component when(toscaOperationFacade.getToscaElement(eq(containerComponentID), any(ComponentParametersView.class))) .thenReturn(Either.left(component)); when(toscaOperationFacade.validateComponentExists(any(String.class))).thenReturn(Either.left(Boolean.TRUE)); when(toscaOperationFacade.getToscaFullElement(eq(new_Comp_UID))).thenReturn(Either.left(component2)); Either, ResponseFormat> resultOp = componentInstanceBusinessLogic .forwardingPathOnVersionChange(containerComponentParam, containerComponentID, componentInstanceID, newComponentInstance); assertEquals(1, resultOp.left().value().size()); assertEquals("FP-ID-1", resultOp.left().value().iterator().next()); } @Test void testCreateOrUpdatePropertiesValues2() { String containerComponentID = "containerId"; String resourceInstanceId = "resourceId"; String componentInstanceID = "componentInstance"; List properties = new ArrayList<>(); ComponentInstanceProperty property = new ComponentInstanceProperty(); property.setName("property"); property.setValue("newVal"); property.setType("string"); properties.add(property); List origProperties = new ArrayList<>(); ComponentInstanceProperty origProperty = new ComponentInstanceProperty(); origProperty.setName("property"); origProperty.setValue("value"); origProperty.setType("string"); origProperties.add(origProperty); Map types = new HashMap<>(); DataTypeDefinition dataTypeDef = new DataTypeDefinition(); types.put("string", dataTypeDef); Component component = new Service(); component.setLastUpdaterUserId("userId"); component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); Map> componentInstanceProps = new HashMap<>(); componentInstanceProps.put("resourceId", origProperties); component.setComponentInstancesProperties(componentInstanceProps); ComponentInstance ci = createComponentInstance("ci1"); ci.setUniqueId("resourceId"); component.setComponentInstances(Arrays.asList(ci, createComponentInstance("ci2"), createComponentInstance(componentInstanceID))); when(toscaOperationFacade.getToscaElement(containerComponentID, JsonParseFlagEnum.ParseAll)) .thenReturn(Either.left(component)); when(graphLockOperation.lockComponent(containerComponentID, NodeTypeEnum.ResourceInstance)) .thenReturn(StorageOperationStatus.OK); when(dataTypeCache.getAll()).thenReturn(Either.left(types)); when(propertyOperation.validateAndUpdatePropertyValue(property.getType(), "newVal", true, null, types)) .thenReturn(Either.left("newVal")); when(propertyOperation.validateAndUpdateRules("string", property.getRules(), null, types, true)).thenReturn(ImmutablePair.of("string", null)); when(toscaOperationFacade.updateComponentInstanceProperty(component, ci.getUniqueId(), origProperty)).thenReturn(StorageOperationStatus.OK); origProperties.get(0).setValue("newVal"); when(toscaOperationFacade.updateComponentInstanceMetadataOfTopologyTemplate(component)) .thenReturn(Either.left(component)); when(janusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK); when(graphLockOperation.unlockComponent(containerComponentID, NodeTypeEnum.ResourceInstance)) .thenReturn(StorageOperationStatus.OK); Either, ResponseFormat> responseFormatEither = componentInstanceBusinessLogic .createOrUpdatePropertiesValues( ComponentTypeEnum.RESOURCE_INSTANCE, containerComponentID, resourceInstanceId, properties, "userId"); assertThat(responseFormatEither.left().value()).isEqualTo(properties); } @Test void testCreateOrUpdatePropertiesValuesPropertyNotExists() { String containerComponentID = "containerId"; String resourceInstanceId = "resourceId"; String componentInstanceID = "componentInstance"; List properties = new ArrayList<>(); ComponentInstanceProperty property = new ComponentInstanceProperty(); property.setName("property"); property.setValue("newVal"); property.setType("string"); properties.add(property); List origProperties = new ArrayList<>(); Component component = new Service(); component.setLastUpdaterUserId("userId"); component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); Map> componentInstanceProps = new HashMap<>(); componentInstanceProps.put("resourceId", origProperties); component.setComponentInstancesProperties(componentInstanceProps); ComponentInstance ci = createComponentInstance("ci1"); ci.setUniqueId("resourceId"); component.setComponentInstances(Arrays.asList(ci, createComponentInstance("ci2"), createComponentInstance(componentInstanceID))); when(toscaOperationFacade.getToscaElement(containerComponentID, JsonParseFlagEnum.ParseAll)) .thenReturn(Either.left(component)); when(graphLockOperation.lockComponent(containerComponentID, NodeTypeEnum.ResourceInstance)) .thenReturn(StorageOperationStatus.OK); when(graphLockOperation.unlockComponent(containerComponentID, NodeTypeEnum.ResourceInstance)) .thenReturn(StorageOperationStatus.OK); try { componentInstanceBusinessLogic.createOrUpdatePropertiesValues( ComponentTypeEnum.RESOURCE_INSTANCE, containerComponentID, resourceInstanceId, properties, "userId"); } catch (ComponentException e) { assertThat(e.getActionStatus()).isEqualTo(ActionStatus.PROPERTY_NOT_FOUND); } } @Test void testCreateOrUpdatePropertiesValuesValidationFailure() { String containerComponentID = "containerId"; String resourceInstanceId = "resourceId"; String componentInstanceID = "componentInstance"; List properties = new ArrayList<>(); ComponentInstanceProperty property = new ComponentInstanceProperty(); property.setName("property"); property.setValue("newVal"); property.setType("string"); properties.add(property); List origProperties = new ArrayList<>(); ComponentInstanceProperty origProperty = new ComponentInstanceProperty(); origProperty.setName("property"); origProperty.setValue("value"); origProperty.setType("string"); origProperties.add(origProperty); Map types = new HashMap<>(); DataTypeDefinition dataTypeDef = new DataTypeDefinition(); types.put("string", dataTypeDef); Component component = new Service(); component.setLastUpdaterUserId("userId"); component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); Map> componentInstanceProps = new HashMap<>(); componentInstanceProps.put("resourceId", origProperties); component.setComponentInstancesProperties(componentInstanceProps); ComponentInstance ci = createComponentInstance("ci1"); ci.setUniqueId("resourceId"); component.setComponentInstances(Arrays.asList(ci, createComponentInstance("ci2"), createComponentInstance(componentInstanceID))); when(toscaOperationFacade.getToscaElement(containerComponentID, JsonParseFlagEnum.ParseAll)) .thenReturn(Either.left(component)); when(graphLockOperation.lockComponent(containerComponentID, NodeTypeEnum.ResourceInstance)) .thenReturn(StorageOperationStatus.OK); when(dataTypeCache.getAll()).thenReturn(Either.left(types)); when(propertyOperation.validateAndUpdatePropertyValue(property.getType(), "newVal", true, null, types)) .thenReturn(Either.right(false)); when(componentsUtils.convertFromStorageResponse(StorageOperationStatus.BAD_REQUEST)) .thenReturn(ActionStatus.INVALID_CONTENT); ComponentException e = assertThrows(ComponentException.class, () -> componentInstanceBusinessLogic.createOrUpdatePropertiesValues( ComponentTypeEnum.RESOURCE_INSTANCE, containerComponentID, resourceInstanceId, properties, "userId")); assertThat(e.getActionStatus()).isEqualTo(ActionStatus.INVALID_CONTENT); } @Test void testCreateOrUpdatePropertiesValuesMissingFieldFailure() { String containerComponentID = "containerId"; String resourceInstanceId = "resourceId"; String componentInstanceID = "componentInstance"; List properties = new ArrayList<>(); ComponentInstanceProperty property = new ComponentInstanceProperty(); property.setValue("newVal"); property.setType("string"); properties.add(property); List origProperties = new ArrayList<>(); ComponentInstanceProperty origProperty = new ComponentInstanceProperty(); origProperty.setName("property"); origProperty.setValue("value"); origProperty.setType("string"); origProperties.add(origProperty); Component component = new Service(); component.setLastUpdaterUserId("userId"); component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); Map> componentInstanceProps = new HashMap<>(); componentInstanceProps.put("resourceId", origProperties); component.setComponentInstancesProperties(componentInstanceProps); ComponentInstance ci = createComponentInstance("ci1"); ci.setUniqueId("resourceId"); component.setComponentInstances(Arrays.asList(ci, createComponentInstance("ci2"), createComponentInstance(componentInstanceID))); when(toscaOperationFacade.getToscaElement(containerComponentID, JsonParseFlagEnum.ParseAll)) .thenReturn(Either.left(component)); when(graphLockOperation.lockComponent(containerComponentID, NodeTypeEnum.ResourceInstance)) .thenReturn(StorageOperationStatus.OK); try { componentInstanceBusinessLogic.createOrUpdatePropertiesValues( ComponentTypeEnum.RESOURCE_INSTANCE, containerComponentID, resourceInstanceId, properties, "userId"); } catch (ComponentException e) { assertThat(e.getActionStatus()).isEqualTo(ActionStatus.MISSING_PROPERTY_NAME); } } @Test void testDeleteForwardingPathsWhenComponentinstanceDeleted() { ComponentTypeEnum containerComponentType = ComponentTypeEnum.findByParamName("services"); String containerComponentID = "Service-comp"; String componentInstanceID = "NodeA1"; Service component = new Service(); component .setComponentInstances(Arrays.asList(createComponentInstance("NodeA2"), createComponentInstance("NodeB2"), createComponentInstance(componentInstanceID))); component.addForwardingPath(createPath("path1", componentInstanceID, "NodeB1", "1")); component.addForwardingPath(createPath("Path2", "NodeA2", "NodeB2", "2")); when(toscaOperationFacade.getToscaElement(eq(containerComponentID), any(ComponentParametersView.class))) .thenReturn(Either.left(component)); when(toscaOperationFacade.getToscaElement(eq(containerComponentID))).thenReturn(Either.left(component)); when(forwardingPathOperation.deleteForwardingPath(any(Service.class), anySet())) .thenReturn(Either.left(new HashSet<>())); final ComponentInstance ci = new ComponentInstance(); ci.setName(componentInstanceID); ComponentInstance responseFormatEither = componentInstanceBusinessLogic .deleteForwardingPathsRelatedTobeDeletedComponentInstance( containerComponentID, containerComponentType, ci); assertThat(!responseFormatEither.isEmpty()).isEqualTo(true); } @Test void testAddComponentInstanceDeploymentArtifacts() { Component containerComponent = new Service(); ComponentInstance componentInstance = new ComponentInstance(); componentInstance.setUniqueId(COMPONENT_INSTANCE_ID); Component originComponent = fillOriginComponent(new Resource()); Map artifacts = new HashMap<>(); ArtifactDefinition deploymentArtifact1 = getArtifact("deploymentArtifact1", ArtifactTypeEnum.HEAT.getType()); artifacts.put(deploymentArtifact1.getArtifactLabel(), deploymentArtifact1); ArtifactDefinition deploymentArtifact2 = getArtifact("deploymentArtifact2", ArtifactTypeEnum.HEAT_ENV.getType()); artifacts.put(deploymentArtifact2.getArtifactLabel(), deploymentArtifact2); ArtifactDefinition deploymentArtifact3 = getArtifact("deploymentArtifact3", ArtifactTypeEnum.HEAT_VOL.getType()); artifacts.put(deploymentArtifact3.getArtifactLabel(), deploymentArtifact3); ArtifactDefinition heatEnvPlaceHolder = getArtifact("deploymentArtifact4", ArtifactTypeEnum.HEAT_ENV.getType()); ArtifactDefinition heatEnvPlaceHolder2 = getArtifact("deploymentArtifact5", ArtifactTypeEnum.HEAT_ENV.getType()); Either, StorageOperationStatus> getResourceDeploymentArtifacts = Either .left(artifacts); Map finalDeploymentArtifacts = new HashMap<>(); finalDeploymentArtifacts.put(deploymentArtifact1.getArtifactLabel(), deploymentArtifact1); finalDeploymentArtifacts.put(deploymentArtifact3.getArtifactLabel(), deploymentArtifact3); finalDeploymentArtifacts.put(heatEnvPlaceHolder.getArtifactLabel(), heatEnvPlaceHolder); finalDeploymentArtifacts.put(heatEnvPlaceHolder2.getArtifactLabel(), heatEnvPlaceHolder2); when(artifactsBusinessLogic.getArtifacts(componentInstance.getComponentUid(), NodeTypeEnum.Resource, ArtifactGroupTypeEnum.DEPLOYMENT, null)).thenReturn(getResourceDeploymentArtifacts); when(artifactsBusinessLogic.createHeatEnvPlaceHolder(new ArrayList<>(), deploymentArtifact1, ArtifactsBusinessLogic.HEAT_ENV_NAME, componentInstance.getUniqueId(), NodeTypeEnum.ResourceInstance, componentInstance.getName(), user, containerComponent, null)).thenReturn(heatEnvPlaceHolder); when(artifactsBusinessLogic.createHeatEnvPlaceHolder(new ArrayList<>(), deploymentArtifact3, ArtifactsBusinessLogic.HEAT_ENV_NAME, componentInstance.getUniqueId(), NodeTypeEnum.ResourceInstance, componentInstance.getName(), user, containerComponent, null)).thenReturn(heatEnvPlaceHolder2); componentInstanceBusinessLogic.setToscaOperationFacade(toscaOperationFacade); when(toscaOperationFacade.addDeploymentArtifactsToInstance(containerComponent.getUniqueId(), componentInstance, finalDeploymentArtifacts)).thenReturn(StorageOperationStatus.OK); when(toscaOperationFacade .addGroupInstancesToComponentInstance(containerComponent, componentInstance, new ArrayList<>(), new HashMap<>())) .thenReturn(StorageOperationStatus.OK); when(toscaOperationFacade .addInformationalArtifactsToInstance(containerComponent.getUniqueId(), componentInstance, null)) .thenReturn(StorageOperationStatus.OK); ActionStatus status = componentInstanceBusinessLogic.addComponentInstanceArtifacts(containerComponent, componentInstance, originComponent, user, null); assertThat(status).isEqualTo(ActionStatus.OK); } private Component fillOriginComponent(Resource originComponent) { originComponent.setUniqueId("resourceId"); originComponent.setUniqueId(ORIGIN_COMPONENT_ID); originComponent.setComponentInstances(Lists.newArrayList(toInstance, fromInstance)); originComponent.setComponentType(ComponentTypeEnum.RESOURCE); originComponent.setState(LifecycleStateEnum.CERTIFIED); return originComponent; } private ArtifactDefinition getArtifact(String artifactLabel, String artifactType) { ArtifactDefinition artifactDefinition = new ArtifactDefinition(); artifactDefinition.setArtifactLabel(artifactLabel); artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT); artifactDefinition.setEsId("esId" + artifactLabel); artifactDefinition.setArtifactType(artifactType); artifactDefinition.setArtifactName("artifactName"); return artifactDefinition; } private ComponentInstance createComponentInstance(String path1) { ComponentInstance componentInstance = new ComponentInstance(); componentInstance.setName(path1); return componentInstance; } private ForwardingPathDataDefinition createPath(String pathName, String fromNode, String toNode, String uniqueId) { ForwardingPathDataDefinition forwardingPath = new ForwardingPathDataDefinition(pathName); forwardingPath.setProtocol("protocol"); forwardingPath.setDestinationPortNumber("port"); forwardingPath.setUniqueId(uniqueId); ListDataDefinition forwardingPathElementListDataDefinition = new ListDataDefinition<>(); forwardingPathElementListDataDefinition .add(new ForwardingPathElementDataDefinition(fromNode, toNode, "nodeAcpType", "nodeBcpType", "nodeDcpName", "nodeBcpName")); forwardingPath.setPathElements(forwardingPathElementListDataDefinition); return forwardingPath; } private Map generateForwardingPath(String componentInstanceID) { ForwardingPathDataDefinition forwardingPath = new ForwardingPathDataDefinition("fpName"); String protocol = "protocol"; forwardingPath.setProtocol(protocol); forwardingPath.setDestinationPortNumber("DestinationPortNumber"); forwardingPath.setUniqueId("FP-ID-1"); ListDataDefinition forwardingPathElementListDataDefinition = new ListDataDefinition<>(); forwardingPathElementListDataDefinition .add(new ForwardingPathElementDataDefinition(componentInstanceID, "nodeB", "nodeA_FORWARDER_CAPABILITY", "nodeBcpType", "nodeDcpName", "nodeBcpName")); forwardingPath.setPathElements(forwardingPathElementListDataDefinition); Map forwardingPaths = new HashMap<>(); forwardingPaths.put("1122", forwardingPath); return forwardingPaths; } private void getServiceRelationByIdSuccess(Component component) { Either getComponentRes = Either.left(component); when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))) .thenReturn(getComponentRes); Either response = componentInstanceBusinessLogic .getRelationById(COMPONENT_ID, RELATION_ID, USER_ID, component.getComponentType()); assertThat(response.isLeft()).isTrue(); } private void getServiceRelationByIdUserValidationFailure(Component component) { when(userValidations.validateUserExists(eq(USER_ID))) .thenThrow(new ByActionStatusComponentException(ActionStatus.USER_NOT_FOUND)); try { componentInstanceBusinessLogic .getRelationById(COMPONENT_ID, RELATION_ID, USER_ID, component.getComponentType()); } catch (ByActionStatusComponentException e) { assertSame(e.getActionStatus(), ActionStatus.USER_NOT_FOUND); } } private void getRelationByIdComponentNotFoundFailure(Component component) { Either getComponentRes = Either.right(StorageOperationStatus.NOT_FOUND); when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))) .thenReturn(getComponentRes); Either response = componentInstanceBusinessLogic .getRelationById(COMPONENT_ID, RELATION_ID, USER_ID, component.getComponentType()); assertThat(response.isRight()).isTrue(); } private void stubMethods() { Mockito.lenient().when(userValidations.validateUserExists(eq(USER_ID))).thenReturn(user); Mockito.lenient().when(componentsUtils .convertFromStorageResponse(eq(StorageOperationStatus.GENERAL_ERROR), any(ComponentTypeEnum.class))) .thenReturn(ActionStatus.GENERAL_ERROR); } private void createComponents() { createRelation(); createInstances(); createProperties(); createInputs(); createService(); createResource(); } private void createResource() { resource = new Resource(); resource.setUniqueId(COMPONENT_ID); resource.setComponentInstancesRelations(Lists.newArrayList(relation)); resource.setComponentInstances(Lists.newArrayList(toInstance, fromInstance)); resource.setCapabilities(toInstance.getCapabilities()); resource.setRequirements(fromInstance.getRequirements()); resource.setComponentType(ComponentTypeEnum.RESOURCE); resource.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); } private void createService() { service = new Service(); service.setUniqueId(COMPONENT_ID); service.setComponentInstancesRelations(Lists.newArrayList(relation)); service.setComponentInstances(Lists.newArrayList(toInstance, fromInstance)); service.setCapabilities(toInstance.getCapabilities()); service.setRequirements(fromInstance.getRequirements()); service.setComponentType(ComponentTypeEnum.SERVICE); service.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); service.setLastUpdaterUserId(USER_ID); Map> ciPropertyMap = new HashMap<>(); ciPropertyMap.put(TO_INSTANCE_ID, ciPropertyList); service.setComponentInstancesProperties(ciPropertyMap); Map> ciInputMap = new HashMap<>(); ciInputMap.put(TO_INSTANCE_ID, ciInputList); service.setComponentInstancesInputs(ciInputMap); } private void createInstances() { toInstance = new ComponentInstance(); toInstance.setUniqueId(TO_INSTANCE_ID); toInstance.setName(TO_INSTANCE_NAME); fromInstance = new ComponentInstance(); fromInstance.setUniqueId(FROM_INSTANCE_ID); CapabilityDataDefinition capability = new CapabilityDataDefinition(); capability.setOwnerId(CAPABILITY_OWNER_ID); capability.setUniqueId(CAPABILITY_UID); capability.setName(CAPABILITY_NAME); Map> capabilities = new HashMap<>(); final CapabilityDefinition capabilityDefinition = new CapabilityDefinition(capability); final ArrayList properties = new ArrayList<>(); properties.add(componentInstancePropInput); capabilityDefinition.setProperties(properties); capabilities.put(capability.getName(), Lists.newArrayList(capabilityDefinition)); RequirementDataDefinition requirement = new RequirementDataDefinition(); requirement.setOwnerId(REQUIREMENT_OWNER_ID); requirement.setUniqueId(REQUIREMENT_UID); requirement.setName(REQUIREMENT_NAME); requirement.setRelationship(RELATIONSHIP_TYPE); Map> requirements = new HashMap<>(); requirements.put(requirement.getCapability(), Lists.newArrayList(new RequirementDefinition(requirement))); toInstance.setCapabilities(capabilities); fromInstance.setRequirements(requirements); } private void createRelation() { relation = new RequirementCapabilityRelDef(); CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship(); RelationshipInfo relationInfo = new RelationshipInfo(); relationInfo.setId(RELATION_ID); relationship.setRelation(relationInfo); relation.setRelationships(Lists.newArrayList(relationship)); relation.setToNode(TO_INSTANCE_ID); relation.setFromNode(FROM_INSTANCE_ID); relationInfo.setCapabilityOwnerId(CAPABILITY_OWNER_ID); relationInfo.setCapabilityUid(CAPABILITY_UID); relationInfo.setCapability(CAPABILITY_NAME); relationInfo.setRequirementOwnerId(REQUIREMENT_OWNER_ID); relationInfo.setRequirementUid(REQUIREMENT_UID); relationInfo.setRequirement(REQUIREMENT_NAME); RelationshipImpl relationshipImpl = new RelationshipImpl(); relationshipImpl.setType(RELATIONSHIP_TYPE); relationInfo.setRelationships(relationshipImpl); } private void createProperties() { // Create GetInputValueData GetInputValueDataDefinition inputValueDef = new GetInputValueDataDefinition(); inputValueDef.setInputId(INPUT_ID); List inputValueDefList = new ArrayList<>(); inputValueDefList.add(inputValueDef); // Create ComponentInstanceProperty ComponentInstanceProperty ciProperty = new ComponentInstanceProperty(); ciProperty.setGetInputValues(inputValueDefList); ciProperty.setName(PROP_NAME); // Create ComponentInstanceProperty list ciPropertyList = new ArrayList<>(); ciPropertyList.add(ciProperty); } private void createInputs() { // Create GetInputValueData GetInputValueDataDefinition inputValueDef = new GetInputValueDataDefinition(); inputValueDef.setInputId(INPUT_ID); List inputValueDefList = new ArrayList<>(); inputValueDefList.add(inputValueDef); // Create ComponentInstanceInput ComponentInstanceInput ciInput = new ComponentInstanceInput(); ciInput.setUniqueId(INPUT_ID); ciInput.setName(PROP_NAME); ciInput.setGetInputValues(inputValueDefList); // Create ComponentInstanceInput list ciInputList = new ArrayList<>(); ciInputList.add(ciInput); } private ComponentInstanceBusinessLogic createTestSubject() { return componentInstanceBusinessLogic; } @Test void testChangeServiceProxyVersion() { ComponentInstanceBusinessLogic componentInstanceBusinessLogic; Either result; // default test componentInstanceBusinessLogic = createTestSubject(); result = componentInstanceBusinessLogic.changeServiceProxyVersion(); assertNotNull(result); } @Test void testCreateServiceProxy() { ComponentInstanceBusinessLogic testSubject; Either result; // default test testSubject = createTestSubject(); result = testSubject.createServiceProxy(); assertNotNull(result); } @Test void testDeleteServiceProxy() { ComponentInstanceBusinessLogic testSubject; Either result; // default test testSubject = createTestSubject(); result = testSubject.deleteServiceProxy(); assertNotNull(result); } @Test void testGetComponentInstanceInputsByInputIdEmpty() { Component component = new Service(); String inputId = ""; List result; result = componentInstanceBusinessLogic.getComponentInstanceInputsByInputId(component, inputId); assertNotNull(result); assertThat(result.isEmpty()).isTrue(); } @Test void testGetComponentInstanceInputsByInputIdPresent() { List result; result = componentInstanceBusinessLogic.getComponentInstanceInputsByInputId(service, INPUT_ID); assertNotNull(result); assertThat(result.isEmpty()).isFalse(); assertThat(result.size()).isOne(); ComponentInstanceInput resultInput = result.get(0); assertThat(resultInput.getComponentInstanceId()).isEqualTo(TO_INSTANCE_ID); assertThat(resultInput.getComponentInstanceName()).isEqualTo(TO_INSTANCE_NAME); } @Test void testGetComponentInstancePropertiesByInputIdEmpty() { Component component = new Service(); String inputId = ""; List result; result = componentInstanceBusinessLogic.getComponentInstancePropertiesByInputId(component, inputId); assertNotNull(result); assertThat(result.isEmpty()).isTrue(); } @Test void testGetComponentInstancePropertiesByInputIdPresent() { List result; result = componentInstanceBusinessLogic.getComponentInstancePropertiesByInputId(service, INPUT_ID); assertNotNull(result); assertThat(result.size()).isOne(); ComponentInstanceProperty resultProperty = result.get(0); assertThat(resultProperty.getComponentInstanceId()).isEqualTo(TO_INSTANCE_ID); assertThat(resultProperty.getComponentInstanceName()).isEqualTo(TO_INSTANCE_NAME); } @Test void testGetRelationById() { ComponentInstanceBusinessLogic testSubject; String componentId = ""; String relationId = ""; String userId = user.getUserId(); ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE_INSTANCE; Either result; // default test testSubject = createTestSubject(); result = testSubject.getRelationById(componentId, relationId, userId, componentTypeEnum); assertNotNull(result); } @Test void testValidateParent() { ComponentInstanceBusinessLogic testSubject; createResource(); String nodeTemplateId = ""; boolean result; // default test testSubject = createTestSubject(); result = Deencapsulation.invoke(testSubject, "validateParent", new Object[]{resource, nodeTemplateId}); assertNotNull(result); } @Test void testGetComponentType() { ComponentInstanceBusinessLogic testSubject; ComponentTypeEnum result; // default test testSubject = createTestSubject(); result = Deencapsulation.invoke(testSubject, "getComponentType", new Object[]{ComponentTypeEnum.class}); assertNotNull(result); } @Test void testGetNewGroupName() { ComponentInstanceBusinessLogic testSubject; String oldPrefix = ""; String newNormailzedPrefix = ""; String qualifiedGroupInstanceName = ""; String result; // test 1 testSubject = createTestSubject(); result = Deencapsulation.invoke(testSubject, "getNewGroupName", new Object[]{oldPrefix, newNormailzedPrefix, qualifiedGroupInstanceName}); assertNotNull(result); } @Test void testUpdateComponentInstanceMetadata_3() { ComponentInstanceBusinessLogic testSubject; createInstances(); ComponentInstance result; // default test testSubject = createTestSubject(); result = Deencapsulation .invoke(testSubject, "updateComponentInstanceMetadata", new Object[]{toInstance, toInstance}); assertNotNull(result); } @Test void testFindRelation() { ComponentInstanceBusinessLogic testSubject; String relationId = ""; List requirementCapabilityRelations = new ArrayList<>(); RequirementCapabilityRelDef result; // default test testSubject = createTestSubject(); result = Deencapsulation.invoke(testSubject, "findRelation", new Object[]{relationId, requirementCapabilityRelations}); } @Test void testCreateOrUpdatePropertiesValues() { ComponentInstanceBusinessLogic testSubject; ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE; createResource(); String componentId = resource.getUniqueId(); String resourceInstanceId = ""; List properties = new ArrayList<>(); String userId = user.getUserId(); Either, ResponseFormat> result; when(toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll)) .thenReturn(Either.left(resource)); // test 1 testSubject = createTestSubject(); result = testSubject .createOrUpdatePropertiesValues(componentTypeEnum, componentId, resourceInstanceId, properties, userId); assertNotNull(result); componentTypeEnum = null; result = testSubject .createOrUpdatePropertiesValues(componentTypeEnum, componentId, resourceInstanceId, properties, userId); assertNotNull(result); result = testSubject .createOrUpdatePropertiesValues(componentTypeEnum, componentId, resourceInstanceId, properties, userId); assertNotNull(result); } @Test void testUpdateCapabilityPropertyOnContainerComponent() { ComponentInstanceBusinessLogic testSubject; ComponentInstanceProperty property = new ComponentInstanceProperty(); String newValue = ""; createResource(); createInstances(); String capabilityType = ""; String capabilityName = ""; ResponseFormat result; // default test testSubject = createTestSubject(); result = Deencapsulation.invoke(testSubject, "updateCapabilityPropertyOnContainerComponent", new Object[]{property, newValue, resource, toInstance, capabilityType, capabilityName}); } @Test void testCreateOrUpdateInstanceInputValues() { ComponentInstanceBusinessLogic testSubject; ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE; createResource(); String componentId = resource.getUniqueId(); String resourceInstanceId = ""; List inputs = new ArrayList<>(); String userId = user.getUserId(); Either, ResponseFormat> result; when(toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll)) .thenReturn(Either.left(resource)); // test 1 testSubject = createTestSubject(); result = testSubject .createOrUpdateInstanceInputValues(componentTypeEnum, componentId, resourceInstanceId, inputs, userId); assertNotNull(result); componentTypeEnum = null; result = testSubject .createOrUpdateInstanceInputValues(componentTypeEnum, componentId, resourceInstanceId, inputs, userId); assertNotNull(result); result = testSubject .createOrUpdateInstanceInputValues(componentTypeEnum, componentId, resourceInstanceId, inputs, userId); assertNotNull(result); } @Test void testCreateOrUpdateGroupInstancePropertyValue() { ComponentInstanceBusinessLogic testSubject; ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE; createResource(); String componentId = resource.getUniqueId(); String resourceInstanceId = ""; String groupInstanceId = ""; ComponentInstanceProperty property = new ComponentInstanceProperty(); String userId = user.getUserId(); Either result; when(toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseMetadata)) .thenReturn(Either.left(resource)); // test 1 testSubject = createTestSubject(); result = testSubject .createOrUpdateGroupInstancePropertyValue(componentTypeEnum, componentId, resourceInstanceId, groupInstanceId, property, userId); assertNotNull(result); componentTypeEnum = null; result = testSubject .createOrUpdateGroupInstancePropertyValue(componentTypeEnum, componentId, resourceInstanceId, groupInstanceId, property, userId); assertNotNull(result); result = testSubject .createOrUpdateGroupInstancePropertyValue(componentTypeEnum, componentId, resourceInstanceId, groupInstanceId, property, userId); assertNotNull(result); } @Test void testDeletePropertyValue() { ComponentInstanceBusinessLogic testSubject; ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE; createService(); String serviceId = service.getUniqueId(); String resourceInstanceId = ""; String propertyValueId = ""; String userId = user.getUserId(); Either result; when(toscaOperationFacade.getToscaElement(serviceId, JsonParseFlagEnum.ParseMetadata)) .thenReturn(Either.left(service)); // test 1 testSubject = createTestSubject(); result = testSubject.deletePropertyValue(componentTypeEnum, serviceId, resourceInstanceId, propertyValueId, userId); assertNotNull(result); componentTypeEnum = null; result = testSubject.deletePropertyValue(componentTypeEnum, serviceId, resourceInstanceId, propertyValueId, userId); assertNotNull(result); result = testSubject.deletePropertyValue(componentTypeEnum, serviceId, resourceInstanceId, propertyValueId, userId); assertNotNull(result); } @Test void testGetComponentParametersViewForForwardingPath() { ComponentInstanceBusinessLogic testSubject; ComponentParametersView result; // default test testSubject = createTestSubject(); result = Deencapsulation.invoke(testSubject, "getComponentParametersViewForForwardingPath"); assertNotNull(result); } @Test void testGetResourceInstanceById() { ComponentInstanceBusinessLogic testSubject; createResource(); String instanceId = ""; Either result; // default test testSubject = createTestSubject(); result = Deencapsulation.invoke(testSubject, "getResourceInstanceById", new Object[]{resource, instanceId}); assertNotNull(result); } @Test void testUpdateInstanceCapabilityProperties_1() { ComponentInstanceBusinessLogic testSubject; ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE; createResource(); String containerComponentId = resource.getUniqueId(); String componentInstanceUniqueId = ""; String capabilityType = ""; String capabilityName = ""; List properties = new ArrayList<>(); String userId = user.getUserId(); Either, ResponseFormat> result; when(toscaOperationFacade.getToscaFullElement(containerComponentId)) .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST)); // test 1 testSubject = createTestSubject(); result = testSubject.updateInstanceCapabilityProperties(componentTypeEnum, containerComponentId, componentInstanceUniqueId, capabilityType, capabilityName, properties, userId); assertNotNull(result); when(toscaOperationFacade.getToscaFullElement(containerComponentId)).thenReturn(Either.left(resource)); result = testSubject.updateInstanceCapabilityProperties(componentTypeEnum, containerComponentId, componentInstanceUniqueId, capabilityType, capabilityName, properties, userId); assertNotNull(result); } @Test void testCopyComponentInstanceWrongUserId() { Either, ResponseFormat> result; ComponentInstance inputComponentInstance = createComponetInstanceFromComponent(resource); String containerComponentId = service.getUniqueId(); String componentInstanceId = resource.getUniqueId(); String oldLastUpdatedUserId = service.getLastUpdaterUserId(); service.setLastUpdaterUserId("wrong user id"); Either leftServiceOp = Either.left(service); when(toscaOperationFacade.getToscaElement(containerComponentId)).thenReturn(leftServiceOp); when(toscaOperationFacade.getToscaElement(eq(containerComponentId), any(ComponentParametersView.class))) .thenReturn(leftServiceOp); when(janusGraphDao.rollback()).thenReturn(JanusGraphOperationStatus.OK); when(graphLockOperation.unlockComponent(Mockito.anyString(), eq(NodeTypeEnum.Service))) .thenReturn(StorageOperationStatus.OK); when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Service))) .thenReturn(StorageOperationStatus.OK); result = componentInstanceBusinessLogic .copyComponentInstance(inputComponentInstance, containerComponentId, componentInstanceId, USER_ID); assertNotNull(result); service.setLastUpdaterUserId(oldLastUpdatedUserId); assertThat(result.isRight()).isTrue(); } @Test void testCopyComponentInstanceComponentWrongState() { Either, ResponseFormat> result; ComponentInstance inputComponentInstance = createComponetInstanceFromComponent(resource); String containerComponentId = service.getUniqueId(); String componentInstanceId = resource.getUniqueId(); String oldServiceLastUpdatedUserId = service.getLastUpdaterUserId(); service.setLastUpdaterUserId(USER_ID); Either leftServiceOp = Either.left(service); when(toscaOperationFacade.getToscaElement(containerComponentId)).thenReturn(leftServiceOp); when(toscaOperationFacade.getToscaElement(eq(containerComponentId), any(ComponentParametersView.class))) .thenReturn(leftServiceOp); when(janusGraphDao.rollback()).thenReturn(JanusGraphOperationStatus.OK); when(graphLockOperation.unlockComponent(Mockito.anyString(), eq(NodeTypeEnum.Service))) .thenReturn(StorageOperationStatus.OK); when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Service))) .thenReturn(StorageOperationStatus.OK); result = componentInstanceBusinessLogic .copyComponentInstance(inputComponentInstance, containerComponentId, componentInstanceId, USER_ID); assertNotNull(result); service.setLastUpdaterUserId(oldServiceLastUpdatedUserId); assertThat(result.isRight()).isTrue(); } @Test void testCopyComponentInstance() { Either, ResponseFormat> result; ComponentInstance inputComponentInstance = createComponetInstanceFromComponent(resource); String containerComponentId = service.getUniqueId(); String componentInstanceId = resource.getUniqueId(); String oldServiceLastUpdatedUserId = service.getLastUpdaterUserId(); service.setLastUpdaterUserId(USER_ID); LifecycleStateEnum oldResourceLifeCycle = resource.getLifecycleState(); resource.setLifecycleState(LifecycleStateEnum.CERTIFIED); Either leftServiceOp = Either.left(service); when(toscaOperationFacade.getToscaElement(containerComponentId)).thenReturn(leftServiceOp); when(toscaOperationFacade.getToscaElement(eq(containerComponentId), any(ComponentParametersView.class))) .thenReturn(leftServiceOp); when(graphLockOperation.unlockComponent(Mockito.anyString(), eq(NodeTypeEnum.Service))) .thenReturn(StorageOperationStatus.OK); when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Service))) .thenReturn(StorageOperationStatus.OK); result = componentInstanceBusinessLogic .copyComponentInstance(inputComponentInstance, containerComponentId, componentInstanceId, USER_ID); assertNotNull(result); service.setLastUpdaterUserId(oldServiceLastUpdatedUserId); resource.setLifecycleState(oldResourceLifeCycle); assertThat(result.isLeft()).isFalse(); } @Test void testCreateOrUpdateAttributeValueForCopyPaste() { ComponentInstance serviceComponentInstance = createComponetInstanceFromComponent(service); ComponentInstanceProperty attribute = new ComponentInstanceProperty(); attribute.setType("string"); attribute.setUniqueId("testCreateOrUpdateAttributeValueForCopyPaste"); SchemaDefinition def = Mockito.mock(SchemaDefinition.class); attribute.setSchema(def); LifecycleStateEnum oldLifeCycleState = service.getLifecycleState(); String oldLastUpdatedUserId = service.getLastUpdaterUserId(); service.setLastUpdaterUserId(USER_ID); service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); Map> instAttrsMap = new HashMap<>(); List instAttrsList = new ArrayList<>(); ComponentInstanceProperty prop = new ComponentInstanceProperty(); prop.setUniqueId(attribute.getUniqueId()); instAttrsList.add(prop); instAttrsMap.put(toInstance.getUniqueId(), instAttrsList); service.setComponentInstancesAttributes(instAttrsMap); Either serviceEitherLeft = Either.left(service); when(toscaOperationFacade.getToscaElement(serviceComponentInstance.getUniqueId(), JsonParseFlagEnum.ParseAll)) .thenReturn(serviceEitherLeft); when(toscaOperationFacade.updateComponentInstanceAttribute(service, toInstance.getUniqueId(), attribute)) .thenReturn(StorageOperationStatus.OK); when(toscaOperationFacade.updateComponentInstanceMetadataOfTopologyTemplate(service)) .thenReturn(serviceEitherLeft); Either result = Deencapsulation .invoke(componentInstanceBusinessLogic, "createOrUpdateAttributeValueForCopyPaste", ComponentTypeEnum.SERVICE, serviceComponentInstance .getUniqueId(), toInstance.getUniqueId(), attribute, USER_ID); assertNotNull(result); service.setLastUpdaterUserId(oldLastUpdatedUserId); service.setLifecycleState(oldLifeCycleState); assertThat(result.isLeft()).isTrue(); ComponentInstanceProperty resultProp = result.left().value(); assertEquals(resultProp.getPath().size(), 1); assertEquals(resultProp.getPath().get(0), toInstance.getUniqueId()); } @Test void testUpdateComponentInstanceProperty() { String containerComponentId = service.getUniqueId(); String componentInstanceId = "dummy_id"; ComponentInstanceProperty property = Mockito.mock(ComponentInstanceProperty.class); Either getComponent = Either.left(service); when(toscaOperationFacade.getToscaElement(containerComponentId)).thenReturn(getComponent); StorageOperationStatus status = StorageOperationStatus.OK; when(toscaOperationFacade.updateComponentInstanceProperty(service, componentInstanceId, property)) .thenReturn(status); Either updateContainerRes = Either.left(service); when(toscaOperationFacade.updateComponentInstanceMetadataOfTopologyTemplate(service)) .thenReturn(updateContainerRes); Either result = Deencapsulation.invoke(componentInstanceBusinessLogic, "updateComponentInstanceProperty", containerComponentId, componentInstanceId, property); assertNotNull(result); assertThat(result.isLeft()).isTrue(); } @Test void testGetInputListDefaultValue() { Component component = service; String inputId = "dummy_id"; String defaultValue = "dummy_default_value"; List newInputs = new ArrayList<>(); InputDefinition in = new InputDefinition(); in.setUniqueId(inputId); in.setDefaultValue(defaultValue); newInputs.add(in); List oldInputs = service.getInputs(); service.setInputs(newInputs); Either result = Deencapsulation.invoke(componentInstanceBusinessLogic, "getInputListDefaultValue", component, inputId); service.setInputs(oldInputs); assertEquals(result.left().value(), defaultValue); } @Test void testBatchDeleteComponentInstanceFailureWrongType() { Map> result; List componentInstanceIdList = new ArrayList<>(); String containerComponentParam = "WRONG_TYPE"; String containerComponentId = "containerComponentId"; String componentInstanceId = "componentInstanceId"; componentInstanceIdList.add(componentInstanceId); Map> deleteErrorMap = new HashMap<>(); List deleteErrorIds = new ArrayList<>(); deleteErrorIds.add(componentInstanceId); deleteErrorMap.put("deleteFailedIds", deleteErrorIds); Either cont = Either.left(service); when(componentsUtils.convertFromStorageResponse(eq(StorageOperationStatus.NOT_FOUND), eq(null))) .thenReturn(ActionStatus.GENERAL_ERROR); when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class))) .thenReturn(cont); try { result = componentInstanceBusinessLogic .batchDeleteComponentInstance(containerComponentParam, containerComponentId, componentInstanceIdList, USER_ID); assertNotNull(result); assertEquals(deleteErrorMap, result); } catch (ComponentException e) { assertEquals(e.getActionStatus().toString(), StorageOperationStatus.GENERAL_ERROR.toString()); } } @Test void testBatchDeleteComponentInstanceFailureCompIds() { String containerComponentParam = ComponentTypeEnum.SERVICE_PARAM_NAME; String containerComponentId = "containerComponentId"; String componentInstanceId = "componentInstanceId"; List componentInstanceIdList = new ArrayList<>(); componentInstanceIdList.add(componentInstanceId); Map> deleteErrorMap = new HashMap<>(); List deleteErrorIds = new ArrayList<>(); deleteErrorIds.add(componentInstanceId); deleteErrorMap.put("deleteFailedIds", deleteErrorIds); Either err = Either.right(StorageOperationStatus.GENERAL_ERROR); when(toscaOperationFacade.getToscaElement(eq(containerComponentId), any(ComponentParametersView.class))) .thenReturn(err); try { Map> result = componentInstanceBusinessLogic.batchDeleteComponentInstance( containerComponentParam, containerComponentId, componentInstanceIdList, USER_ID); assertNotNull(result); assertEquals(deleteErrorMap, result); } catch (ComponentException e) { assertEquals(e.getActionStatus().toString(), StorageOperationStatus.GENERAL_ERROR.toString()); } } @Test void testBatchDeleteComponentInstanceSuccess() { Map> 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; List componentInstanceIdList = new ArrayList<>(); componentInstanceIdList.add(componentInstanceId); Map> deleteErrorMap = new HashMap<>(); List deleteErrorIds = new ArrayList<>(); deleteErrorMap.put("deleteFailedIds", deleteErrorIds); Either 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 pair = new ImmutablePair<>(resource, TO_INSTANCE_ID); Either, StorageOperationStatus> result2 = Either.left(pair); when(toscaOperationFacade.deleteComponentInstanceFromTopologyTemplate(service, componentInstanceId)) .thenReturn(result2); when(toscaOperationFacade.getToscaElement(eq(service.getUniqueId()), any(ComponentParametersView.class))) .thenReturn(cont); when(janusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK); result = componentInstanceBusinessLogic .batchDeleteComponentInstance(containerComponentParam, containerComponentId, componentInstanceIdList, USER_ID); assertNotNull(result); service.setLastUpdaterUserId(oldLastUpdatedUserId); service.setLifecycleState(oldLifeCycleState); assertEquals(deleteErrorMap, result); } @Test void testDissociateRIFromRIFailDissociate() { List result; RequirementCapabilityRelDef ref = new RequirementCapabilityRelDef(); ref.setFromNode(FROM_INSTANCE_ID); ref.setToNode(TO_INSTANCE_ID); List 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 requirementDefList = new ArrayList<>(); requirementDefList.add(ref); ComponentTypeEnum componentTypeEnum = service.getComponentType(); String componentId = service.getUniqueId(); LifecycleStateEnum oldLifeCycleState = service.getLifecycleState(); String oldLastUpdatedUserId = service.getLastUpdaterUserId(); service.setLastUpdaterUserId(USER_ID); service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); Either 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 resultEither; resultEither = Either.right(StorageOperationStatus.OK); when(componentsUtils.convertFromStorageResponseForResourceInstance(eq(StorageOperationStatus.OK), eq(true))) .thenReturn(ActionStatus.GENERAL_ERROR); when(toscaOperationFacade.dissociateResourceInstances(componentId, ref)).thenReturn(resultEither); try { result = componentInstanceBusinessLogic .batchDissociateRIFromRI(componentId, USER_ID, requirementDefList, componentTypeEnum); assertNotNull(result); assertEquals(new ArrayList<>(), result); } catch (ComponentException e) { assertEquals(e.getActionStatus().toString(), StorageOperationStatus.GENERAL_ERROR.toString()); } service.setLastUpdaterUserId(oldLastUpdatedUserId); service.setLifecycleState(oldLifeCycleState); } @Test void testDissociateRIFromRISuccess() { List result; RequirementCapabilityRelDef ref = new RequirementCapabilityRelDef(); List requirementDefList = new ArrayList<>(); requirementDefList.add(ref); ComponentTypeEnum componentTypeEnum = service.getComponentType(); String componentId = service.getUniqueId(); LifecycleStateEnum oldLifeCycleState = service.getLifecycleState(); String oldLastUpdatedUserId = service.getLastUpdaterUserId(); service.setLastUpdaterUserId(USER_ID); service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); Either 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 resultEither; resultEither = Either.left(ref); when(toscaOperationFacade.dissociateResourceInstances(componentId, ref)).thenReturn(resultEither); result = componentInstanceBusinessLogic .batchDissociateRIFromRI(componentId, USER_ID, requirementDefList, componentTypeEnum); assertNotNull(result); service.setLastUpdaterUserId(oldLastUpdatedUserId); service.setLifecycleState(oldLifeCycleState); assertEquals(requirementDefList, result); } @Test void testGetComponentInstancePropertyByPolicyId_success() { Optional propertyCandidate = getComponentInstanceProperty(PROP_NAME); assertThat(propertyCandidate.isPresent()).isTrue(); assertEquals(propertyCandidate.get().getName(), PROP_NAME); } @Test void testGetComponentInstancePropertyByPolicyId_failure() { Optional propertyCandidate = getComponentInstanceProperty(NON_EXIST_NAME); assertEquals(propertyCandidate, Optional.empty()); } private Optional getComponentInstanceProperty(String propertyName) { ComponentInstanceProperty componentInstanceProperty = new ComponentInstanceProperty(); componentInstanceProperty.setName(propertyName); PolicyDefinition policyDefinition = getPolicyDefinition(); componentInstanceProperty.setGetPolicyValues(policyDefinition.getGetPolicyValues()); service.setComponentInstancesProperties( Collections.singletonMap(COMPONENT_INSTANCE_ID, Collections.singletonList(componentInstanceProperty))); return componentInstanceBusinessLogic.getComponentInstancePropertyByPolicyId(service, policyDefinition); } private PolicyDefinition getPolicyDefinition() { PolicyDefinition policyDefinition = new PolicyDefinition(); policyDefinition.setInstanceUniqueId(COMPONENT_INSTANCE_ID); policyDefinition.setName(PROP_NAME); GetPolicyValueDataDefinition getPolicy = new GetPolicyValueDataDefinition(); getPolicy.setPropertyName(PROP_NAME); List getPolicies = new ArrayList<>(); getPolicies.add(getPolicy); policyDefinition.setGetPolicyValues(getPolicies); return policyDefinition; } private ComponentInstance createComponetInstanceFromComponent(Component component) { ComponentInstance componentInst = new ComponentInstance(); componentInst.setUniqueId(component.getUniqueId()); componentInst.setComponentUid(component.getUniqueId() + "_test"); componentInst.setPosX("10"); componentInst.setPosY("10"); componentInst.setCapabilities(component.getCapabilities()); componentInst.setRequirements(component.getRequirements()); componentInst.setArtifacts(component.getArtifacts()); componentInst.setDeploymentArtifacts(component.getDeploymentArtifacts()); return componentInst; } // Prepare ComponentInstance & Resource objects used in createComponentInstance() tests private Pair prepareResourcesForCreateComponentInstanceTest() { ComponentInstance instanceToBeCreated = new ComponentInstance(); instanceToBeCreated.setName(COMPONENT_INSTANCE_NAME); instanceToBeCreated.setUniqueId(COMPONENT_INSTANCE_ID); instanceToBeCreated.setComponentUid(ORIGIN_COMPONENT_ID); instanceToBeCreated.setOriginType(OriginTypeEnum.VF); Resource originComponent = new Resource(); originComponent.setLifecycleState(LifecycleStateEnum.CERTIFIED); originComponent.setResourceType(ResourceTypeEnum.VF); originComponent.setVersion(ORIGIN_COMPONENT_VERSION); originComponent.setIcon(ICON_NAME); return Pair.of(instanceToBeCreated, originComponent); } // Common part for testing component instance name validation private void testCreateComponentInstanceNameValidationFailure(String ciName) { ComponentInstance ci = new ComponentInstance(); ci.setName(ciName); // Stub for getting component when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))) .thenReturn(Either.left(service)); // Expecting ByActionStatusComponentException ByActionStatusComponentException e = assertThrows(ByActionStatusComponentException.class, () -> { componentInstanceBusinessLogic.createComponentInstance(ComponentTypeEnum.SERVICE_PARAM_NAME, COMPONENT_ID, USER_ID, ci); }); assertEquals(ActionStatus.INVALID_COMPONENT_NAME, e.getActionStatus()); } @TestFactory Iterable testCreateComponentInstanceNameValidationFailureFactory() { String longName = String.join("", Collections.nCopies(ValidationUtils.COMPONENT_NAME_MAX_LENGTH + 1, "x")); String invalidName = "componentInstance#name"; return Arrays.asList( dynamicTest("instance name is empty", () -> testCreateComponentInstanceNameValidationFailure("")), dynamicTest("instance name is too long", () -> testCreateComponentInstanceNameValidationFailure(longName)), dynamicTest("instance name includes invalid character", () -> testCreateComponentInstanceNameValidationFailure(invalidName)) ); } @Test void testCreateComponentInstanceFailToGetComponent() { ComponentInstance ci = prepareResourcesForCreateComponentInstanceTest().getLeft(); // Stub for getting component when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))) .thenReturn(Either.left(service)); when(toscaOperationFacade.getToscaFullElement(eq(ORIGIN_COMPONENT_ID))) .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND)); when(componentsUtils.convertFromStorageResponse(StorageOperationStatus.NOT_FOUND, ComponentTypeEnum.RESOURCE)) .thenReturn(ActionStatus.RESOURCE_NOT_FOUND); ByActionStatusComponentException e = assertThrows(ByActionStatusComponentException.class, () -> { componentInstanceBusinessLogic.createComponentInstance(ComponentTypeEnum.SERVICE_PARAM_NAME, COMPONENT_ID, USER_ID, ci); }); assertThat(e.getActionStatus()).isEqualTo(ActionStatus.RESOURCE_NOT_FOUND); } @Test void testCreateComponentInstanceFailureInvalidState() { Pair p = prepareResourcesForCreateComponentInstanceTest(); ComponentInstance ci = p.getLeft(); Resource originComponent = p.getRight(); originComponent.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); // Stub for getting component when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))) .thenReturn(Either.left(service)); when(toscaOperationFacade.getToscaFullElement(eq(ORIGIN_COMPONENT_ID))) .thenReturn(Either.left(originComponent)); ByActionStatusComponentException e = assertThrows(ByActionStatusComponentException.class, () -> { componentInstanceBusinessLogic.createComponentInstance(ComponentTypeEnum.SERVICE_PARAM_NAME, COMPONENT_ID, USER_ID, ci); }); assertThat(e.getActionStatus()).isEqualTo(ActionStatus.CONTAINER_CANNOT_CONTAIN_COMPONENT_IN_STATE); } @Test void testCreateComponentInstanceFailureArchived() { Pair p = prepareResourcesForCreateComponentInstanceTest(); ComponentInstance ci = p.getLeft(); Resource originComponent = p.getRight(); originComponent.setArchived(Boolean.TRUE); // Stub for getting component when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))) .thenReturn(Either.left(service)); when(toscaOperationFacade.getToscaFullElement(eq(ORIGIN_COMPONENT_ID))) .thenReturn(Either.left(originComponent)); ByActionStatusComponentException e = assertThrows(ByActionStatusComponentException.class, () -> { componentInstanceBusinessLogic.createComponentInstance(ComponentTypeEnum.SERVICE_PARAM_NAME, COMPONENT_ID, USER_ID, ci); }); assertThat(e.getActionStatus()).isEqualTo(ActionStatus.COMPONENT_IS_ARCHIVED); } @Test void testCreateComponentInstanceFailureInvalidOriginType() { Pair p = prepareResourcesForCreateComponentInstanceTest(); ComponentInstance ci = p.getLeft(); Resource originComponent = p.getRight(); ci.setOriginType(OriginTypeEnum.VFC); // Set different type from origin // Stub for getting component when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))) .thenReturn(Either.left(service)); when(toscaOperationFacade.getToscaFullElement(eq(ORIGIN_COMPONENT_ID))) .thenReturn(Either.left(originComponent)); ByActionStatusComponentException e = assertThrows(ByActionStatusComponentException.class, () -> { componentInstanceBusinessLogic.createComponentInstance(ComponentTypeEnum.SERVICE_PARAM_NAME, COMPONENT_ID, USER_ID, ci); }); assertThat(e.getActionStatus()).isEqualTo(ActionStatus.INVALID_CONTENT); } @Test void testCreateComponentInstanceFailureCannotContainInstance() { Pair p = prepareResourcesForCreateComponentInstanceTest(); ComponentInstance ci = p.getLeft(); Resource originComponent = p.getRight(); // Stub for getting component when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))) .thenReturn(Either.left(service)); when(toscaOperationFacade.getToscaFullElement(eq(ORIGIN_COMPONENT_ID))) .thenReturn(Either.left(originComponent)); // Assume services cannot contain VF resource when(containerInstanceTypeData.getServiceContainerList()) .thenReturn(Collections.singletonList(ResourceTypeEnum.VL)); ByActionStatusComponentException e = assertThrows(ByActionStatusComponentException.class, () -> { componentInstanceBusinessLogic.createComponentInstance(ComponentTypeEnum.SERVICE_PARAM_NAME, COMPONENT_ID, USER_ID, ci); }); assertThat(e.getActionStatus()).isEqualTo(ActionStatus.CONTAINER_CANNOT_CONTAIN_INSTANCE); verify(containerInstanceTypeData, times(1)).getServiceContainerList(); } @Test void testCreateComponentInstanceFailureAddToGraph() { Pair p = prepareResourcesForCreateComponentInstanceTest(); ComponentInstance ci = p.getLeft(); Resource originComponent = p.getRight(); // TODO Refactor createComponentInstance() method and reduce these mocks // not to target the internal details too much when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))) .thenReturn(Either.left(service)); when(toscaOperationFacade.getToscaFullElement(eq(ORIGIN_COMPONENT_ID))) .thenReturn(Either.left(originComponent)); when(containerInstanceTypeData.getServiceContainerList()) .thenReturn(Collections.singletonList(ResourceTypeEnum.VF)); Mockito.doNothing().when(compositionBusinessLogic).validateAndSetDefaultCoordinates(ci); when(graphLockOperation.lockComponent(COMPONENT_ID, NodeTypeEnum.Service)) .thenReturn(StorageOperationStatus.OK); when(toscaOperationFacade.addComponentInstanceToTopologyTemplate(service, originComponent, ci, false, user)) .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST)); when(componentsUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.BAD_REQUEST, true)) .thenReturn(ActionStatus.INVALID_CONTENT); when(componentsUtils.getResponseFormatForResourceInstance(ActionStatus.INVALID_CONTENT, "", null)) .thenReturn(new ResponseFormat()); when(janusGraphDao.rollback()).thenReturn(JanusGraphOperationStatus.OK); when(graphLockOperation.unlockComponent(COMPONENT_ID, NodeTypeEnum.Service)) .thenReturn(StorageOperationStatus.OK); assertThrows(ByResponseFormatComponentException.class, () -> { componentInstanceBusinessLogic.createComponentInstance(ComponentTypeEnum.SERVICE_PARAM_NAME, COMPONENT_ID, USER_ID, ci); }); verify(containerInstanceTypeData, times(1)).getServiceContainerList(); verify(compositionBusinessLogic, times(1)).validateAndSetDefaultCoordinates(ci); verify(toscaOperationFacade, times(1)) .addComponentInstanceToTopologyTemplate(service, originComponent, ci, false, user); verify(graphLockOperation, times(1)).unlockComponent(COMPONENT_ID, NodeTypeEnum.Service); } @Test void testCreateComponentInstanceSuccess() { Pair p = prepareResourcesForCreateComponentInstanceTest(); ComponentInstance instanceToBeCreated = p.getLeft(); Resource originComponent = p.getRight(); Service updatedService = new Service(); updatedService.setComponentInstances(Collections.singletonList(instanceToBeCreated)); updatedService.setUniqueId(service.getUniqueId()); // TODO Refactor createComponentInstance() method and reduce these mocks // not to target the internal details too much when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))) .thenReturn(Either.left(service)); when(toscaOperationFacade.getToscaFullElement(eq(ORIGIN_COMPONENT_ID))) .thenReturn(Either.left(originComponent)); when(containerInstanceTypeData.getServiceContainerList()) .thenReturn(Collections.singletonList(ResourceTypeEnum.VF)); Mockito.doNothing().when(compositionBusinessLogic).validateAndSetDefaultCoordinates(instanceToBeCreated); when(graphLockOperation.lockComponent(COMPONENT_ID, NodeTypeEnum.Service)) .thenReturn(StorageOperationStatus.OK); when(toscaOperationFacade.addComponentInstanceToTopologyTemplate(service, originComponent, instanceToBeCreated, false, user)) .thenReturn(Either.left(new ImmutablePair<>(updatedService, COMPONENT_INSTANCE_ID))); when(artifactsBusinessLogic.getArtifacts( ORIGIN_COMPONENT_ID, NodeTypeEnum.Resource, ArtifactGroupTypeEnum.DEPLOYMENT, null)) .thenReturn(Either.left(new HashMap<>())); when(toscaOperationFacade .addInformationalArtifactsToInstance(service.getUniqueId(), instanceToBeCreated, originComponent.getArtifacts())) .thenReturn(StorageOperationStatus.OK); when(janusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK); when(graphLockOperation.unlockComponent(COMPONENT_ID, NodeTypeEnum.Service)) .thenReturn(StorageOperationStatus.OK); ComponentInstance result = componentInstanceBusinessLogic.createComponentInstance( ComponentTypeEnum.SERVICE_PARAM_NAME, COMPONENT_ID, USER_ID, instanceToBeCreated); assertThat(result).isEqualTo(instanceToBeCreated); assertThat(instanceToBeCreated.getComponentVersion()).isEqualTo(originComponent.getVersion()); assertThat(instanceToBeCreated.getIcon()).isEqualTo(originComponent.getIcon()); verify(containerInstanceTypeData, times(1)).getServiceContainerList(); verify(compositionBusinessLogic, times(1)).validateAndSetDefaultCoordinates(instanceToBeCreated); verify(toscaOperationFacade, times(1)) .addComponentInstanceToTopologyTemplate(service, originComponent, instanceToBeCreated, false, user); // Check graph db change was committed verify(janusGraphDao, times(1)).commit(); } }