package org.openecomp.sdc.be.components.impl;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.DynamicTest.dynamicTest;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anySet;
import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import static org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum.RESOURCE_PARAM_NAME;
import fj.data.Either;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
+import java.util.Map.Entry;
import java.util.Optional;
import java.util.Set;
+import java.util.stream.Stream;
import mockit.Deencapsulation;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.apache.commons.lang3.tuple.Pair;
import org.assertj.core.util.Lists;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
+import org.junit.jupiter.api.BeforeAll;
+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.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
-import org.mockito.junit.MockitoJUnitRunner;
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.impl.exceptions.ToscaFunctionExceptionSupplier;
+import org.openecomp.sdc.be.components.impl.exceptions.ToscaGetFunctionExceptionSupplier;
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.JanusGraphDao;
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.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.elements.ToscaGetFunctionDataDefinition;
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.PropertySource;
+import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
+import org.openecomp.sdc.be.datatypes.tosca.ToscaGetFunctionType;
+import org.openecomp.sdc.be.exception.BusinessException;
import org.openecomp.sdc.be.impl.ComponentsUtils;
-import org.openecomp.sdc.be.impl.ServletUtils;
import org.openecomp.sdc.be.model.ArtifactDefinition;
import org.openecomp.sdc.be.model.CapabilityDefinition;
import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
import org.openecomp.sdc.be.model.Component;
import org.openecomp.sdc.be.model.ComponentInstance;
+import org.openecomp.sdc.be.model.ComponentInstanceAttribute;
import org.openecomp.sdc.be.model.ComponentInstanceInput;
import org.openecomp.sdc.be.model.ComponentInstancePropInput;
import org.openecomp.sdc.be.model.ComponentInstanceProperty;
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.PropertyDefinition;
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.Service;
import org.openecomp.sdc.be.model.User;
import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
+import org.openecomp.sdc.be.model.jsonjanusgraph.config.ContainerInstanceTypesData;
import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ForwardingPathOperation;
import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
+import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.OperationException;
import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation;
import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
-import org.openecomp.sdc.be.user.UserBusinessLogic;
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
*/
-
-@RunWith(MockitoJUnitRunner.class)
-public class ComponentInstanceBusinessLogicTest {
+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 COMPONENT_INST_ID = "componentInstId";
+ 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 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";
- static ConfigurationSource configurationSource = new FSConfigurationSource(
- ExternalConfiguration.getChangeListener(),
- "src/test/resources/config/catalog-be");
- static ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
-
- @InjectMocks
- private static ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
+ private ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
@Mock
private ComponentInstancePropInput componentInstancePropInput;
@Mock
- ArtifactsBusinessLogic artifactsBusinessLogic;
+ private ArtifactsBusinessLogic artifactsBusinessLogic;
@Mock
private ComponentsUtils componentsUtils;
@Mock
- private ServletUtils servletUtils;
- @Mock
- private ResponseFormat responseFormat;
- @Mock
private ToscaOperationFacade toscaOperationFacade;
@Mock
- private UserBusinessLogic userAdmin;
- @Mock
private ForwardingPathOperation forwardingPathOperation;
@Mock
private User user;
@Mock
private UserValidations userValidations;
@Mock
- GraphLockOperation graphLockOperation;
+ private GraphLockOperation graphLockOperation;
@Mock
private JanusGraphDao janusGraphDao;
@Mock
- ApplicationDataTypeCache dataTypeCache;
+ private ApplicationDataTypeCache applicationDataTypeCache;
+ @Mock
+ private PropertyOperation propertyOperation;
@Mock
- PropertyOperation propertyOperation;
+ private ContainerInstanceTypesData containerInstanceTypeData;
@Mock
- ApplicationDataTypeCache applicationDataTypeCache;
+ private CompositionBusinessLogic compositionBusinessLogic;
private Component service;
private Component resource;
private ComponentInstance toInstance;
private ComponentInstance fromInstance;
- private CapabilityDataDefinition capability;
- private RequirementDataDefinition requirement;
private RequirementCapabilityRelDef relation;
+ private List<ComponentInstanceProperty> ciPropertyList;
+ private List<ComponentInstanceInput> ciInputList;
+
+ @BeforeAll
+ static void beforeAll() {
+ initConfig();
+ }
+
+ private static void initConfig() {
+ final ConfigurationSource configurationSource = new FSConfigurationSource(
+ ExternalConfiguration.getChangeListener(),
+ "src/test/resources/config/catalog-be"
+ );
+ new ConfigurationManager(configurationSource);
+ }
+
+ @BeforeEach
+ void init() {
+ MockitoAnnotations.openMocks(this);
+ componentInstanceBusinessLogic = new ComponentInstanceBusinessLogic(null, null, null, null, null, null, null, artifactsBusinessLogic, null,
+ null, forwardingPathOperation, null, null);
+ componentInstanceBusinessLogic.setComponentsUtils(componentsUtils);
+ componentInstanceBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
+ componentInstanceBusinessLogic.setUserValidations(userValidations);
+ componentInstanceBusinessLogic.setGraphLockOperation(graphLockOperation);
+ componentInstanceBusinessLogic.setJanusGraphDao(janusGraphDao);
+ componentInstanceBusinessLogic.setApplicationDataTypeCache(applicationDataTypeCache);
+ componentInstanceBusinessLogic.setPropertyOperation(propertyOperation);
+ componentInstanceBusinessLogic.setContainerInstanceTypesData(containerInstanceTypeData);
+ componentInstanceBusinessLogic.setCompositionBusinessLogic(compositionBusinessLogic);
- @Before
- public void init() {
- MockitoAnnotations.initMocks(componentInstanceBusinessLogic);
stubMethods();
createComponents();
}
@Test
- public void testGetRelationByIdSuccess() {
+ void testGetRelationByIdSuccess() {
getServiceRelationByIdSuccess(service);
getServiceRelationByIdSuccess(resource);
}
@Test
- public void testGetRelationByIdUserValidationFailure() {
+ void testGetRelationByIdUserValidationFailure() {
getServiceRelationByIdUserValidationFailure(service);
getServiceRelationByIdUserValidationFailure(resource);
}
@Test
- public void testGetRelationByIdComponentNotFoundFailure() {
+ void testGetRelationByIdComponentNotFoundFailure() {
getRelationByIdComponentNotFoundFailure(service);
getRelationByIdComponentNotFoundFailure(resource);
}
@Test
- public void testForwardingPathOnVersionChange() {
+ void testForwardingPathOnVersionChange() {
getforwardingPathOnVersionChange();
}
@Test
- public void testIsCloudSpecificArtifact() {
- assertTrue(componentInstanceBusinessLogic.isCloudSpecificArtifact(ARTIFACT_1));
- assertTrue(componentInstanceBusinessLogic.isCloudSpecificArtifact(ARTIFACT_2));
- assertTrue(componentInstanceBusinessLogic.isCloudSpecificArtifact(ARTIFACT_3));
- assertFalse(componentInstanceBusinessLogic.isCloudSpecificArtifact(ARTIFACT_4));
- assertFalse(componentInstanceBusinessLogic.isCloudSpecificArtifact(ARTIFACT_5));
+ 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() {
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));
+ when(toscaOperationFacade.getToscaFullElement(new_Comp_UID)).thenReturn(Either.left(component2));
Either<Set<String>, ResponseFormat> resultOp = componentInstanceBusinessLogic
.forwardingPathOnVersionChange(containerComponentParam,
}
@Test
- public void testCreateOrUpdatePropertiesValues2() {
+ void testCreateOrUpdatePropertiesValues2() {
String containerComponentID = "containerId";
String resourceInstanceId = "resourceId";
String componentInstanceID = "componentInstance";
ci.setUniqueId("resourceId");
component.setComponentInstances(Arrays.asList(ci, createComponentInstance("ci2"),
createComponentInstance(componentInstanceID)));
- HashMap<String, DataTypeDefinition> dataTypeDefinitionHashMap = new HashMap<>();
- DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
- dataTypeDefinition.setName("string");
- dataTypeDefinitionHashMap.put("string", dataTypeDefinition);
- //when(userValidations.validateUserExists(user.getUserId(), false)).thenReturn(user);
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(componentsUtils.getAllDataTypes(applicationDataTypeCache, component.getModel())).thenReturn(types);
when(propertyOperation.validateAndUpdatePropertyValue(property.getType(), "newVal", true, null, types))
.thenReturn(Either.left("newVal"));
when(propertyOperation.validateAndUpdateRules("string", property.getRules(),
}
@Test
- public void testCreateOrUpdatePropertiesValuesPropertyNotExists() {
+ void testToscaGetFunctionValidation() {
+ final String userId = "userId";
+ final String containerComponentId = "containerComponentId";
+ final String containerComponentName = "containerComponentName";
+ final String resourceInstanceId = "resourceInstanceId";
+ final String inputName = "myInputToGet";
+ final String inputId = String.format("%s.%s", containerComponentId, inputName);
+ final String schemaType = "string";
+ //creating instance list of string property with get_input value
+ final ComponentInstanceProperty propertyGetInput = new ComponentInstanceProperty();
+ propertyGetInput.setName("getInputProperty");
+ propertyGetInput.setPropertyId(String.format("%s.%s", containerComponentId, "getInputProperty"));
+ propertyGetInput.setValue(String.format("get_input: [\"%s\"]", inputName));
+ propertyGetInput.setType("list");
+ final SchemaDefinition listStringPropertySchema = createSchema(schemaType);
+ propertyGetInput.setSchema(listStringPropertySchema);
+ propertyGetInput.setToscaFunction(
+ createGetToscaFunction(inputName, inputId, List.of(propertyGetInput.getName()), PropertySource.SELF, ToscaGetFunctionType.GET_INPUT,
+ containerComponentId, containerComponentName)
+ );
+ //creating instance map of string property with get_input value to a second level property:
+ // get_input: ["property1", "subProperty1", "subProperty2"]
+ final String getPropertyPropertyName = "getPropertyProperty";
+ final List<String> containerPropertyPath = List.of("property1", "subProperty1", "subProperty2");
+ final String containerPropertyId = String.format("%s.%s", containerComponentId, containerPropertyPath.get(0));
+ final String mapToscaType = "map";
+ final ComponentInstanceProperty propertyGetProperty = createComponentInstanceProperty(
+ String.format("%s.%s", containerComponentId, getPropertyPropertyName),
+ getPropertyPropertyName,
+ mapToscaType,
+ "string",
+ String.format("\"get_property\": [\"%s\", \"%s\"]", PropertySource.SELF, String.join("\", \"", containerPropertyPath)),
+ createGetToscaFunction(containerPropertyPath.get(containerPropertyPath.size() - 1), containerPropertyId,
+ containerPropertyPath, PropertySource.SELF, ToscaGetFunctionType.GET_PROPERTY, containerComponentId, containerComponentName)
+ );
+
+ //creating component that has the instance properties
+ final Component component = new Service();
+ component.setUniqueId(containerComponentId);
+ component.setName(containerComponentName);
+ component.setLastUpdaterUserId(userId);
+ component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+ //adding instance properties to the component
+ final List<ComponentInstanceProperty> resourceInstanceProperties = List.of(propertyGetInput, propertyGetProperty);
+ final Map<String, List<ComponentInstanceProperty>> componentInstanceProps = new HashMap<>();
+ componentInstanceProps.put(resourceInstanceId, resourceInstanceProperties);
+ component.setComponentInstancesProperties(componentInstanceProps);
+
+ //creating component input that will be gotten by the get_input instance property
+ final var inputDefinition = new InputDefinition();
+ inputDefinition.setName(inputName);
+ inputDefinition.setUniqueId(inputId);
+ inputDefinition.setType(propertyGetInput.getType());
+ inputDefinition.setSchema(listStringPropertySchema);
+ component.setInputs(List.of(inputDefinition));
+
+ //creating component property that contains the sub property that will be gotten by the get_property instance property
+ final var propertyDefinition = new PropertyDefinition();
+ propertyDefinition.setName(containerPropertyPath.get(0));
+ propertyDefinition.setUniqueId(containerPropertyId);
+ final String property1Type = "property1.datatype";
+ propertyDefinition.setType(property1Type);
+ component.setProperties(List.of(propertyDefinition));
+ //creating resource instance to be added to the component
+ final ComponentInstance resourceInstance = createComponentInstance("resourceInstance");
+ resourceInstance.setUniqueId(resourceInstanceId);
+ component.setComponentInstances(List.of(resourceInstance));
+
+ mockComponentForToscaGetFunctionValidation(component);
+
+ //creating data types for "map", and sub properties
+ final Map<String, DataTypeDefinition> allDataTypesMap = new HashMap<>();
+ allDataTypesMap.put(mapToscaType, new DataTypeDefinition());
+
+ final String subProperty1Type = "subProperty1.datatype";
+ allDataTypesMap.put(property1Type, createDataType(property1Type, Map.of(containerPropertyPath.get(1), subProperty1Type)));
+
+ final var subProperty2Property = new PropertyDefinition();
+ subProperty2Property.setName(containerPropertyPath.get(2));
+ subProperty2Property.setType(propertyGetProperty.getType());
+ subProperty2Property.setSchema(propertyGetProperty.getSchema());
+ allDataTypesMap.put(subProperty1Type, createDataType(subProperty1Type, List.of(subProperty2Property)));
+
+ when(applicationDataTypeCache.getAll(component.getModel())).thenReturn(Either.left(allDataTypesMap));
+ //when
+ final Either<List<ComponentInstanceProperty>, ResponseFormat> actualResponseFormat = componentInstanceBusinessLogic
+ .createOrUpdatePropertiesValues(
+ ComponentTypeEnum.RESOURCE_INSTANCE, containerComponentId, resourceInstanceId, resourceInstanceProperties, userId);
+ //then
+ assertTrue(actualResponseFormat.isLeft());
+ assertThat(actualResponseFormat.left().value()).isEqualTo(resourceInstanceProperties);
+ }
+
+ @Test
+ void testToscaGetPropertyOnInstanceValidation() {
+ final String userId = "userId";
+ final String containerComponentId = "containerComponentId";
+ final String containerComponentName = "containerComponentName";
+ final String instanceUniqueId = String.format("%s.%s", containerComponentId, "instanceId");
+
+ final List<String> parentPropertyPath = List.of("property1");
+ final String containerPropertyId = String.format("%s.%s", containerComponentId, parentPropertyPath.get(0));
+ final ComponentInstanceProperty getPropertyOnInstanceProperty = createComponentInstanceProperty(
+ String.format("%s.%s", containerComponentId, "getPropertyOnInstanceProperty"),
+ "getPropertyOnInstanceProperty",
+ "string",
+ null,
+ String.format("\"get_property\": [\"%s\", \"%s\"]", PropertySource.INSTANCE, parentPropertyPath.get(0)),
+ createGetToscaFunction(parentPropertyPath.get(0), containerPropertyId, parentPropertyPath, PropertySource.INSTANCE,
+ ToscaGetFunctionType.GET_PROPERTY, instanceUniqueId, containerComponentName)
+ );
+
+ //creating component that has the instance properties
+ final Component component = new Service();
+ component.setUniqueId(containerComponentId);
+ component.setName(containerComponentName);
+ component.setLastUpdaterUserId(userId);
+ component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+ //adding instance properties to the component
+ final List<ComponentInstanceProperty> resourceInstanceProperties = List.of(getPropertyOnInstanceProperty);
+ final Map<String, List<ComponentInstanceProperty>> componentInstanceProps = new HashMap<>();
+ componentInstanceProps.put(instanceUniqueId, resourceInstanceProperties);
+ component.setComponentInstancesProperties(componentInstanceProps);
+
+ //creating resource property that will be get
+ final var propertyDefinition = new PropertyDefinition();
+ propertyDefinition.setName(parentPropertyPath.get(0));
+ propertyDefinition.setUniqueId(containerPropertyId);
+ final String property1Type = "string";
+ propertyDefinition.setType(property1Type);
+ //creating resource instance to be added to the component
+ final ComponentInstance resourceInstance = createComponentInstance("resourceInstance");
+ resourceInstance.setUniqueId(instanceUniqueId);
+ resourceInstance.setProperties(List.of(propertyDefinition));
+ component.setComponentInstances(List.of(resourceInstance));
+
+ mockComponentForToscaGetFunctionValidation(component);
+
+ //when
+ final Either<List<ComponentInstanceProperty>, ResponseFormat> actualResponseFormat = componentInstanceBusinessLogic
+ .createOrUpdatePropertiesValues(
+ ComponentTypeEnum.RESOURCE_INSTANCE, containerComponentId, instanceUniqueId, resourceInstanceProperties, userId);
+ //then
+ assertTrue(actualResponseFormat.isLeft());
+ assertThat(actualResponseFormat.left().value()).isEqualTo(resourceInstanceProperties);
+ }
+
+ private DataTypeDefinition createDataType(final String name, final Map<String, String> propertyNameAndTypeMap) {
+ final var dataTypeDefinition = new DataTypeDefinition();
+ dataTypeDefinition.setName(name);
+ if (MapUtils.isNotEmpty(propertyNameAndTypeMap)) {
+ for (final Entry<String, String> propertyEntry : propertyNameAndTypeMap.entrySet()) {
+ final var propertyDefinition = new PropertyDefinition();
+ propertyDefinition.setName(propertyEntry.getKey());
+ propertyDefinition.setType(propertyEntry.getValue());
+ dataTypeDefinition.setProperties(List.of(propertyDefinition));
+ }
+ }
+ return dataTypeDefinition;
+ }
+
+ private DataTypeDefinition createDataType(final String name, final List<PropertyDefinition> propertyList) {
+ final var dataTypeDefinition = new DataTypeDefinition();
+ dataTypeDefinition.setName(name);
+ if (CollectionUtils.isNotEmpty(propertyList)) {
+ dataTypeDefinition.setProperties(propertyList);
+ }
+ return dataTypeDefinition;
+ }
+
+ private ComponentInstanceProperty createComponentInstanceProperty(final String uniqueId, final String name, final String type,
+ final String schemaType, final String value,
+ final ToscaGetFunctionDataDefinition toscaGetFunction) {
+ final var componentInstanceProperty = new ComponentInstanceProperty();
+ componentInstanceProperty.setName(name);
+ componentInstanceProperty.setUniqueId(uniqueId);
+ componentInstanceProperty.setType(type);
+ componentInstanceProperty.setValue(value);
+ if (schemaType != null) {
+ final SchemaDefinition schemaDefinition = createSchema(schemaType);
+ componentInstanceProperty.setSchema(schemaDefinition);
+ }
+ if (toscaGetFunction != null) {
+ componentInstanceProperty.setToscaFunction(toscaGetFunction);
+ }
+
+ return componentInstanceProperty;
+ }
+
+ @Test
+ void testToscaGetFunctionValidation_schemaDivergeTest() {
+ final String userId = "userId";
+ final String containerComponentId = "containerComponentId";
+ final String containerComponentName = "containerComponentName";
+ final String resourceInstanceId = "resourceInstanceId";
+ final String inputName = "myInputToGet";
+ final String inputId = String.format("%s.%s", containerComponentId, inputName);
+ final String propertyName = "getInputProperty";
+ final String propertyId = String.format("%s.%s", containerComponentId, propertyName);
+ final String propertyType = "list";
+ final List<ComponentInstanceProperty> properties = new ArrayList<>();
+ final ComponentInstanceProperty propertyGetInput = createComponentInstanceProperty(
+ propertyId,
+ "getInputProperty",
+ propertyType,
+ "string",
+ String.format("get_input: [\"%s\"]", inputName),
+ createGetToscaFunction(inputName, inputId, List.of(propertyName), PropertySource.SELF, ToscaGetFunctionType.GET_INPUT,
+ containerComponentId, containerComponentName)
+ );
+ properties.add(propertyGetInput);
+
+ final Component component = new Service();
+ component.setUniqueId(containerComponentId);
+ component.setName(containerComponentName);
+ component.setLastUpdaterUserId(userId);
+ component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+
+ var inputDefinition = new InputDefinition();
+ inputDefinition.setName(inputName);
+ inputDefinition.setUniqueId(inputId);
+ inputDefinition.setType(propertyType);
+ inputDefinition.setSchema(createSchema("integer"));
+ component.setInputs(List.of(inputDefinition));
+
+ final Map<String, List<ComponentInstanceProperty>> componentInstanceProps = new HashMap<>();
+ componentInstanceProps.put(resourceInstanceId, properties);
+ component.setComponentInstancesProperties(componentInstanceProps);
+
+ final ComponentInstance resourceInstance = createComponentInstance("componentInstance1");
+ resourceInstance.setUniqueId(resourceInstanceId);
+ component.setComponentInstances(List.of(resourceInstance));
+
+ mockComponentForToscaGetFunctionValidation(component);
+ //when
+ final Either<List<ComponentInstanceProperty>, ResponseFormat> responseFormatEither =
+ componentInstanceBusinessLogic
+ .createOrUpdatePropertiesValues(ComponentTypeEnum.RESOURCE_INSTANCE, containerComponentId, resourceInstanceId, properties, userId);
+ //then
+ assertTrue(responseFormatEither.isRight(), "Expecting an error");
+ final ResponseFormat actualResponse = responseFormatEither.right().value();
+ final ResponseFormat expectedResponse =
+ ToscaGetFunctionExceptionSupplier
+ .propertySchemaDiverge(propertyGetInput.getToscaFunction().getType(), inputDefinition.getSchemaType(),
+ propertyGetInput.getSchemaType())
+ .get().getResponseFormat();
+ assertEquals(expectedResponse.getFormattedMessage(), actualResponse.getFormattedMessage());
+ assertEquals(expectedResponse.getStatus(), actualResponse.getStatus());
+ }
+
+ @Test
+ void testToscaGetFunctionValidation_propertyTypeDivergeTest() {
+ final String userId = "userId";
+ final String containerComponentId = "containerComponentId";
+ final String containerComponentName = "containerComponentName";
+ final String resourceInstanceId = "resourceInstanceId";
+ final String inputName = "myInputToGet";
+ final String inputId = String.format("%s.%s", containerComponentId, inputName);
+ final String propertyName = "getInputProperty";
+ final String propertyId = String.format("%s.%s", containerComponentId, propertyName);
+ final String propertyType = "string";
+ final List<ComponentInstanceProperty> properties = new ArrayList<>();
+ final ComponentInstanceProperty propertyGetInput = createComponentInstanceProperty(
+ propertyId,
+ "getInputProperty",
+ propertyType,
+ "string",
+ String.format("get_input: [\"%s\"]", inputName),
+ createGetToscaFunction(inputName, inputId, List.of(propertyName), PropertySource.SELF, ToscaGetFunctionType.GET_INPUT,
+ containerComponentId, containerComponentName)
+ );
+ properties.add(propertyGetInput);
+
+ final Component component = new Service();
+ component.setName(containerComponentName);
+ component.setUniqueId(containerComponentId);
+ component.setLastUpdaterUserId(userId);
+ component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+
+ var inputDefinition = new InputDefinition();
+ inputDefinition.setName(inputName);
+ inputDefinition.setUniqueId(inputId);
+ inputDefinition.setType("integer");
+ component.setInputs(List.of(inputDefinition));
+
+ final Map<String, List<ComponentInstanceProperty>> componentInstanceProps = new HashMap<>();
+ componentInstanceProps.put(resourceInstanceId, properties);
+ component.setComponentInstancesProperties(componentInstanceProps);
+
+ final ComponentInstance resourceInstance = createComponentInstance("componentInstance1");
+ resourceInstance.setUniqueId(resourceInstanceId);
+ component.setComponentInstances(List.of(resourceInstance));
+
+ mockComponentForToscaGetFunctionValidation(component);
+ //when
+ final Either<List<ComponentInstanceProperty>, ResponseFormat> responseFormatEither =
+ componentInstanceBusinessLogic
+ .createOrUpdatePropertiesValues(ComponentTypeEnum.RESOURCE_INSTANCE, containerComponentId, resourceInstanceId, properties, userId);
+ //then
+ assertTrue(responseFormatEither.isRight(), "Expecting an error");
+ final ResponseFormat actualResponse = responseFormatEither.right().value();
+ final ResponseFormat expectedResponse =
+ ToscaGetFunctionExceptionSupplier
+ .propertyTypeDiverge(propertyGetInput.getToscaFunction().getType(), inputDefinition.getType(), propertyGetInput.getType())
+ .get().getResponseFormat();
+ assertEquals(expectedResponse.getFormattedMessage(), actualResponse.getFormattedMessage());
+ assertEquals(expectedResponse.getStatus(), actualResponse.getStatus());
+ }
+
+ @ParameterizedTest
+ @MethodSource("getToscaFunctionForValidation")
+ void testToscaGetFunctionValidation_AttributesNotFoundTest(final ToscaGetFunctionDataDefinition toscaGetFunction,
+ final ResponseFormat expectedValidationResponse) {
+ final String userId = "userId";
+ final String containerComponentId = "containerComponentId";
+ final String containerComponentName = "containerComponentName";
+ final String resourceInstanceId = "resourceInstanceId";
+ final List<ComponentInstanceProperty> properties = new ArrayList<>();
+ final ComponentInstanceProperty propertyGetInput = new ComponentInstanceProperty();
+ propertyGetInput.setName("anyName");
+ propertyGetInput.setToscaFunction(toscaGetFunction);
+ properties.add(propertyGetInput);
+
+ final Component component = new Service();
+ component.setName(containerComponentName);
+ component.setUniqueId(containerComponentId);
+ component.setLastUpdaterUserId(userId);
+ component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+
+ final Map<String, List<ComponentInstanceProperty>> componentInstanceProps = new HashMap<>();
+ componentInstanceProps.put(resourceInstanceId, properties);
+ component.setComponentInstancesProperties(componentInstanceProps);
+
+ final ComponentInstance resourceInstance = createComponentInstance("componentInstance1");
+ resourceInstance.setUniqueId(resourceInstanceId);
+ component.setComponentInstances(List.of(resourceInstance));
+
+ mockComponentForToscaGetFunctionValidation(component);
+ //when
+ final Either<List<ComponentInstanceProperty>, ResponseFormat> responseFormatEither =
+ componentInstanceBusinessLogic
+ .createOrUpdatePropertiesValues(ComponentTypeEnum.RESOURCE_INSTANCE, containerComponentId, resourceInstanceId, properties, userId);
+ //then
+ assertTrue(responseFormatEither.isRight(), "Expecting an error");
+ final ResponseFormat actualResponse = responseFormatEither.right().value();
+ assertEquals(expectedValidationResponse.getFormattedMessage(), actualResponse.getFormattedMessage());
+ assertEquals(expectedValidationResponse.getStatus(), actualResponse.getStatus());
+ }
+
+ @Test
+ void testToscaGetFunctionValidation_propertyNotFoundTest() {
+ final String userId = "userId";
+ final String containerComponentId = "containerComponentId";
+ final String containerComponentName = "containerComponentName";
+ final String resourceInstanceId = "resourceInstanceId";
+ final String inputName = "myInputToGet";
+ final String inputId = String.format("%s.%s", containerComponentId, inputName);
+ final String propertyName = "getInputProperty";
+ final String propertyId = String.format("%s.%s", containerComponentId, propertyName);
+ final String propertyType = "string";
+ final List<ComponentInstanceProperty> properties = new ArrayList<>();
+ final ComponentInstanceProperty propertyGetInput = createComponentInstanceProperty(
+ propertyId,
+ "getInputProperty",
+ propertyType,
+ "string",
+ String.format("get_input: [\"%s\"]", inputName),
+ createGetToscaFunction(inputName, inputId, List.of(propertyName), PropertySource.SELF, ToscaGetFunctionType.GET_INPUT,
+ containerComponentId, containerComponentName)
+ );
+ properties.add(propertyGetInput);
+
+ final Component component = new Service();
+ component.setName(containerComponentName);
+ component.setUniqueId(containerComponentId);
+ component.setLastUpdaterUserId(userId);
+ component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+
+ final Map<String, List<ComponentInstanceProperty>> componentInstanceProps = new HashMap<>();
+ componentInstanceProps.put(resourceInstanceId, properties);
+ component.setComponentInstancesProperties(componentInstanceProps);
+
+ final ComponentInstance resourceInstance = createComponentInstance("componentInstance1");
+ resourceInstance.setUniqueId(resourceInstanceId);
+ component.setComponentInstances(List.of(resourceInstance));
+
+ mockComponentForToscaGetFunctionValidation(component);
+ //when
+ final Either<List<ComponentInstanceProperty>, ResponseFormat> responseFormatEither =
+ componentInstanceBusinessLogic
+ .createOrUpdatePropertiesValues(ComponentTypeEnum.RESOURCE_INSTANCE, containerComponentId, resourceInstanceId, properties, userId);
+ //then
+ assertTrue(responseFormatEither.isRight(), "Expecting an error");
+ final ResponseFormat actualResponse = responseFormatEither.right().value();
+ final ResponseFormat expectedResponse =
+ ToscaGetFunctionExceptionSupplier
+ .propertyNotFoundOnTarget(inputName, PropertySource.SELF, ToscaGetFunctionType.GET_INPUT)
+ .get().getResponseFormat();
+ assertEquals(expectedResponse.getFormattedMessage(), actualResponse.getFormattedMessage());
+ assertEquals(expectedResponse.getStatus(), actualResponse.getStatus());
+ }
+
+ @Test
+ void testCreateOrUpdatePropertiesValuesPropertyNotExists() {
String containerComponentID = "containerId";
String resourceInstanceId = "resourceId";
String componentInstanceID = "componentInstance";
List<ComponentInstanceProperty> origProperties = new ArrayList<>();
- Map<String, DataTypeDefinition> types = new HashMap<>();
- DataTypeDefinition dataTypeDef = new DataTypeDefinition();
- types.put("string", dataTypeDef);
-
Component component = new Service();
component.setLastUpdaterUserId("userId");
component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
ci.setUniqueId("resourceId");
component.setComponentInstances(Arrays.asList(ci, createComponentInstance("ci2"),
createComponentInstance(componentInstanceID)));
- HashMap<String, DataTypeDefinition> dataTypeDefinitionHashMap = new HashMap<>();
- DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
- dataTypeDefinition.setName("string");
- dataTypeDefinitionHashMap.put("string", dataTypeDefinition);
- //when(userValidations.validateUserExists(user.getUserId(), false)).thenReturn(user);
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 (janusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
when(graphLockOperation.unlockComponent(containerComponentID, NodeTypeEnum.ResourceInstance))
.thenReturn(StorageOperationStatus.OK);
}
@Test
- public void testCreateOrUpdatePropertiesValuesValidationFailure() {
+ void testCreateOrUpdatePropertiesValuesValidationFailure() {
String containerComponentID = "containerId";
String resourceInstanceId = "resourceId";
String componentInstanceID = "componentInstance";
ci.setUniqueId("resourceId");
component.setComponentInstances(Arrays.asList(ci, createComponentInstance("ci2"),
createComponentInstance(componentInstanceID)));
- HashMap<String, DataTypeDefinition> dataTypeDefinitionHashMap = new HashMap<>();
- DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
- dataTypeDefinition.setName("string");
- dataTypeDefinitionHashMap.put("string", dataTypeDefinition);
- //when(userValidations.validateUserExists(user.getUserId(), false)).thenReturn(user);
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(componentsUtils.getAllDataTypes(applicationDataTypeCache, component.getModel())).thenReturn(types);
when(propertyOperation.validateAndUpdatePropertyValue(property.getType(), "newVal", true, null, types))
.thenReturn(Either.right(false));
when(componentsUtils.convertFromStorageResponse(StorageOperationStatus.BAD_REQUEST))
.thenReturn(ActionStatus.INVALID_CONTENT);
- try {
- componentInstanceBusinessLogic.createOrUpdatePropertiesValues(
- ComponentTypeEnum.RESOURCE_INSTANCE, containerComponentID, resourceInstanceId, properties, "userId");
- } catch (ComponentException e) {
- assertThat(e.getActionStatus()).isEqualTo(ActionStatus.INVALID_CONTENT);
- return;
- }
- fail();
+ final Either<List<ComponentInstanceProperty>, ResponseFormat> response = componentInstanceBusinessLogic.createOrUpdatePropertiesValues(
+ ComponentTypeEnum.RESOURCE_INSTANCE, containerComponentID, resourceInstanceId, properties, "userId");
+ assertThat(response.isRight()).as("Response should be an error").isTrue();
+ final ResponseFormat responseFormat = response.right().value();
+ assertThat(responseFormat.getStatus()).as("Response status should be as expected").isEqualTo(400);
+ assertThat(responseFormat.getMessageId()).as("Error message id should be as expected").isEqualTo("SVC4000");
}
@Test
- public void testCreateOrUpdatePropertiesValuesMissingFieldFailure() {
+ void testCreateOrUpdatePropertiesValuesMissingFieldFailure() {
String containerComponentID = "containerId";
String resourceInstanceId = "resourceId";
String componentInstanceID = "componentInstance";
component.setComponentInstances(Arrays.asList(ci, createComponentInstance("ci2"),
createComponentInstance(componentInstanceID)));
- HashMap<String, DataTypeDefinition> dataTypeDefinitionHashMap = new HashMap<>();
- DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
- dataTypeDefinition.setName("string");
- dataTypeDefinitionHashMap.put("string", dataTypeDefinition);
-
- //when(userValidations.validateUserExists(user.getUserId(), false)).thenReturn(user);
when(toscaOperationFacade.getToscaElement(containerComponentID, JsonParseFlagEnum.ParseAll))
.thenReturn(Either.left(component));
when(graphLockOperation.lockComponent(containerComponentID, NodeTypeEnum.ResourceInstance))
}
@Test
- public void testDeleteForwardingPathsWhenComponentinstanceDeleted() {
+ void testDeleteForwardingPathsWhenComponentinstanceDeleted() {
ComponentTypeEnum containerComponentType = ComponentTypeEnum.findByParamName("services");
String containerComponentID = "Service-comp";
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(toscaOperationFacade.getToscaElement(containerComponentID)).thenReturn(Either.left(component));
when(forwardingPathOperation.deleteForwardingPath(any(Service.class), anySet()))
.thenReturn(Either.left(new HashSet<>()));
final ComponentInstance ci = new ComponentInstance();
ComponentInstance responseFormatEither = componentInstanceBusinessLogic
.deleteForwardingPathsRelatedTobeDeletedComponentInstance(
containerComponentID, containerComponentType, ci);
- assertThat(!responseFormatEither.isEmpty()).isEqualTo(true);
-
+ assertFalse(responseFormatEither.isEmpty());
}
@Test
- public void testAddComponentInstanceDeploymentArtifacts() {
+ void testAddComponentInstanceDeploymentArtifacts() {
Component containerComponent = new Service();
ComponentInstance componentInstance = new ComponentInstance();
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<>(),
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, null, new HashMap<>()))
+ .addGroupInstancesToComponentInstance(containerComponent, componentInstance, new ArrayList<>(),
+ new HashMap<>()))
.thenReturn(StorageOperationStatus.OK);
when(toscaOperationFacade
.addInformationalArtifactsToInstance(containerComponent.getUniqueId(), componentInstance, null))
artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
artifactDefinition.setEsId("esId" + artifactLabel);
artifactDefinition.setArtifactType(artifactType);
+ artifactDefinition.setArtifactName("artifactName");
return artifactDefinition;
}
return forwardingPaths;
}
- @SuppressWarnings("unchecked")
private void getServiceRelationByIdSuccess(Component component) {
Either<Component, StorageOperationStatus> getComponentRes = Either.left(component);
when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class)))
.getRelationById(COMPONENT_ID,
RELATION_ID, USER_ID,
component.getComponentType());
- assertTrue(response.isLeft());
+ assertThat(response.isLeft()).isTrue();
}
private void getServiceRelationByIdUserValidationFailure(Component component) {
- when(userValidations.validateUserExists(eq(USER_ID)))
- .thenThrow(new ByActionStatusComponentException(ActionStatus.USER_NOT_FOUND));
+ doThrow(new ByActionStatusComponentException(ActionStatus.USER_NOT_FOUND)).when(userValidations).validateUserExists(USER_ID);
try {
componentInstanceBusinessLogic
.getRelationById(COMPONENT_ID, RELATION_ID, USER_ID, component.getComponentType());
} catch (ByActionStatusComponentException e) {
- assertSame(e.getActionStatus(), ActionStatus.USER_NOT_FOUND);
+ assertSame(ActionStatus.USER_NOT_FOUND, e.getActionStatus());
}
}
private void getRelationByIdComponentNotFoundFailure(Component component) {
- Either<User, ActionStatus> eitherCreator = Either.left(user);
Either<Component, StorageOperationStatus> getComponentRes = Either.right(StorageOperationStatus.NOT_FOUND);
when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class)))
.thenReturn(getComponentRes);
.getRelationById(COMPONENT_ID,
RELATION_ID, USER_ID,
component.getComponentType());
- assertTrue(response.isRight());
+ assertThat(response.isRight()).isTrue();
}
private void stubMethods() {
- when(userValidations.validateUserExists(eq(USER_ID))).thenReturn(user);
- when(componentsUtils
+ 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();
+ resource = createResource();
}
- private void createResource() {
- resource = new Resource();
+ private Resource createResource() {
+ final Resource resource = new Resource();
resource.setUniqueId(COMPONENT_ID);
resource.setComponentInstancesRelations(Lists.newArrayList(relation));
resource.setComponentInstances(Lists.newArrayList(toInstance, fromInstance));
resource.setRequirements(fromInstance.getRequirements());
resource.setComponentType(ComponentTypeEnum.RESOURCE);
resource.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+ return resource;
}
private void createService() {
service.setRequirements(fromInstance.getRequirements());
service.setComponentType(ComponentTypeEnum.SERVICE);
service.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+ service.setLastUpdaterUserId(USER_ID);
+
+ Map<String, List<ComponentInstanceProperty>> ciPropertyMap = new HashMap<>();
+ ciPropertyMap.put(TO_INSTANCE_ID, ciPropertyList);
+ service.setComponentInstancesProperties(ciPropertyMap);
+
+ Map<String, List<ComponentInstanceInput>> ciInputMap = new HashMap<>();
+ ciInputMap.put(TO_INSTANCE_ID, ciInputList);
+ service.setComponentInstancesInputs(ciInputMap);
}
private void createInstances() {
fromInstance = new ComponentInstance();
fromInstance.setUniqueId(FROM_INSTANCE_ID);
- capability = new CapabilityDataDefinition();
+ CapabilityDataDefinition capability = new CapabilityDataDefinition();
capability.setOwnerId(CAPABILITY_OWNER_ID);
capability.setUniqueId(CAPABILITY_UID);
capability.setName(CAPABILITY_NAME);
capabilityDefinition.setProperties(properties);
capabilities.put(capability.getName(), Lists.newArrayList(capabilityDefinition));
- requirement = new RequirementDataDefinition();
+ RequirementDataDefinition requirement = new RequirementDataDefinition();
requirement.setOwnerId(REQUIREMENT_OWNER_ID);
requirement.setUniqueId(REQUIREMENT_UID);
requirement.setName(REQUIREMENT_NAME);
toInstance.setCapabilities(capabilities);
fromInstance.setRequirements(requirements);
+
}
private void createRelation() {
relationInfo.setRelationships(relationshipImpl);
}
+ private void createProperties() {
+ // Create GetInputValueData
+ GetInputValueDataDefinition inputValueDef = new GetInputValueDataDefinition();
+ inputValueDef.setInputId(INPUT_ID);
+ List<GetInputValueDataDefinition> 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<GetInputValueDataDefinition> 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
- public void testChangeServiceProxyVersion() {
+ void testChangeServiceProxyVersion() {
ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
Either<ComponentInstance, ResponseFormat> result;
// default test
componentInstanceBusinessLogic = createTestSubject();
result = componentInstanceBusinessLogic.changeServiceProxyVersion();
- Assert.assertNotNull(result);
+ assertNotNull(result);
}
@Test
- public void testCreateServiceProxy() {
+ void testCreateServiceProxy() {
ComponentInstanceBusinessLogic testSubject;
Either<ComponentInstance, ResponseFormat> result;
// default test
testSubject = createTestSubject();
result = testSubject.createServiceProxy();
- Assert.assertNotNull(result);
+ assertNotNull(result);
}
@Test
- public void testDeleteServiceProxy() {
+ void testDeleteServiceProxy() {
ComponentInstanceBusinessLogic testSubject;
Either<ComponentInstance, ResponseFormat> result;
// default test
testSubject = createTestSubject();
result = testSubject.deleteServiceProxy();
- Assert.assertNotNull(result);
+ assertNotNull(result);
}
@Test
- public void testGetComponentInstanceInputsByInputId() {
- ComponentInstanceBusinessLogic testSubject;
+ void testGetComponentInstanceInputsByInputIdEmpty() {
Component component = new Service();
String inputId = "";
List<ComponentInstanceInput> result;
- // default test
- testSubject = createTestSubject();
- result = testSubject.getComponentInstanceInputsByInputId(component, inputId);
- Assert.assertNotNull(result);
+ result = componentInstanceBusinessLogic.getComponentInstanceInputsByInputId(component, inputId);
+ assertNotNull(result);
+ assertThat(result.isEmpty()).isTrue();
}
@Test
- public void testGetComponentInstancePropertiesByInputId() {
- ComponentInstanceBusinessLogic testSubject;
+ void testGetComponentInstanceInputsByInputIdPresent() {
+ List<ComponentInstanceInput> 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<ComponentInstanceProperty> result;
- // default test
- testSubject = createTestSubject();
- result = testSubject.getComponentInstancePropertiesByInputId(component, inputId);
- Assert.assertNotNull(result);
+ result = componentInstanceBusinessLogic.getComponentInstancePropertiesByInputId(component, inputId);
+ assertNotNull(result);
+ assertThat(result.isEmpty()).isTrue();
}
@Test
- public void testGetRelationById() {
+ void testGetComponentInstancePropertiesByInputIdPresent() {
+ List<ComponentInstanceProperty> 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 = "";
// default test
testSubject = createTestSubject();
result = testSubject.getRelationById(componentId, relationId, userId, componentTypeEnum);
- Assert.assertNotNull(result);
+ assertNotNull(result);
}
@Test
- public void testValidateParent() {
+ void testValidateParent() {
ComponentInstanceBusinessLogic testSubject;
- createResource();
+ resource = createResource();
String nodeTemplateId = "";
boolean result;
// default test
testSubject = createTestSubject();
result = Deencapsulation.invoke(testSubject, "validateParent", new Object[]{resource, nodeTemplateId});
- Assert.assertNotNull(result);
+ assertFalse(result);
}
@Test
- public void testGetComponentType() {
+ void testGetComponentType() {
ComponentInstanceBusinessLogic testSubject;
ComponentTypeEnum result;
// default test
testSubject = createTestSubject();
result = Deencapsulation.invoke(testSubject, "getComponentType", new Object[]{ComponentTypeEnum.class});
- Assert.assertNotNull(result);
+ assertNotNull(result);
}
@Test
- public void testGetNewGroupName() {
+ void testGetNewGroupName() {
ComponentInstanceBusinessLogic testSubject;
String oldPrefix = "";
String newNormailzedPrefix = "";
testSubject = createTestSubject();
result = Deencapsulation.invoke(testSubject, "getNewGroupName",
new Object[]{oldPrefix, newNormailzedPrefix, qualifiedGroupInstanceName});
- Assert.assertNotNull(result);
+ assertNotNull(result);
}
@Test
- public void testUpdateComponentInstanceMetadata_3() {
+ void testUpdateComponentInstanceMetadata_3() {
ComponentInstanceBusinessLogic testSubject;
createInstances();
- ComponentInstance newComponentInstance = null;
ComponentInstance result;
// default test
testSubject = createTestSubject();
result = Deencapsulation
.invoke(testSubject, "updateComponentInstanceMetadata", new Object[]{toInstance, toInstance});
- Assert.assertNotNull(result);
+ assertNotNull(result);
}
@Test
- public void testFindRelation() throws Exception {
+ void testFindRelation() {
ComponentInstanceBusinessLogic testSubject;
String relationId = "";
List<RequirementCapabilityRelDef> requirementCapabilityRelations = new ArrayList<>();
testSubject = createTestSubject();
result = Deencapsulation.invoke(testSubject, "findRelation",
new Object[]{relationId, requirementCapabilityRelations});
+ assertNull(result);
}
@Test
- public void testCreateOrUpdatePropertiesValues() throws Exception {
+ void testCreateOrUpdatePropertiesValues() {
ComponentInstanceBusinessLogic testSubject;
ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
- createResource();
+ resource = createResource();
String componentId = resource.getUniqueId();
String resourceInstanceId = "";
List<ComponentInstanceProperty> properties = new ArrayList<>();
result = testSubject
.createOrUpdatePropertiesValues(componentTypeEnum, componentId, resourceInstanceId, properties,
userId);
- Assert.assertNotNull(result);
+ assertNotNull(result);
componentTypeEnum = null;
result = testSubject
.createOrUpdatePropertiesValues(componentTypeEnum, componentId, resourceInstanceId, properties,
userId);
- Assert.assertNotNull(result);
+ assertNotNull(result);
result = testSubject
.createOrUpdatePropertiesValues(componentTypeEnum, componentId, resourceInstanceId, properties,
userId);
- Assert.assertNotNull(result);
+ assertNotNull(result);
}
@Test
- public void testUpdateCapabilityPropertyOnContainerComponent() throws Exception {
+ void testUpdateCapabilityPropertyOnContainerComponent() {
ComponentInstanceBusinessLogic testSubject;
ComponentInstanceProperty property = new ComponentInstanceProperty();
String newValue = "";
- createResource();
+ resource = createResource();
createInstances();
String capabilityType = "";
String capabilityName = "";
testSubject = createTestSubject();
result = Deencapsulation.invoke(testSubject, "updateCapabilityPropertyOnContainerComponent",
new Object[]{property, newValue, resource, toInstance, capabilityType, capabilityName});
+ assertNull(result);
}
@Test
- public void testCreateOrUpdateInstanceInputValues() throws Exception {
+ void testCreateOrUpdateInstanceInputValues() {
ComponentInstanceBusinessLogic testSubject;
ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
- createResource();
+ resource = createResource();
String componentId = resource.getUniqueId();
String resourceInstanceId = "";
List<ComponentInstanceInput> inputs = new ArrayList<>();
result = testSubject
.createOrUpdateInstanceInputValues(componentTypeEnum, componentId, resourceInstanceId, inputs,
userId);
- Assert.assertNotNull(result);
+ assertNotNull(result);
componentTypeEnum = null;
result = testSubject
.createOrUpdateInstanceInputValues(componentTypeEnum, componentId, resourceInstanceId, inputs,
userId);
- Assert.assertNotNull(result);
+ assertNotNull(result);
result = testSubject
.createOrUpdateInstanceInputValues(componentTypeEnum, componentId, resourceInstanceId, inputs,
userId);
- Assert.assertNotNull(result);
+ assertNotNull(result);
}
@Test
- public void testCreateOrUpdateGroupInstancePropertyValue() throws Exception {
+ void testCreateOrUpdateGroupInstancePropertyValue() {
ComponentInstanceBusinessLogic testSubject;
ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
- createResource();
+ resource = createResource();
String componentId = resource.getUniqueId();
String resourceInstanceId = "";
String groupInstanceId = "";
result = testSubject
.createOrUpdateGroupInstancePropertyValue(componentTypeEnum, componentId, resourceInstanceId,
groupInstanceId, property, userId);
- Assert.assertNotNull(result);
+ assertNotNull(result);
componentTypeEnum = null;
result = testSubject
.createOrUpdateGroupInstancePropertyValue(componentTypeEnum, componentId, resourceInstanceId,
groupInstanceId, property, userId);
- Assert.assertNotNull(result);
+ assertNotNull(result);
result = testSubject
.createOrUpdateGroupInstancePropertyValue(componentTypeEnum, componentId, resourceInstanceId,
groupInstanceId, property, userId);
- Assert.assertNotNull(result);
+ assertNotNull(result);
}
@Test
- public void testDeletePropertyValue() throws Exception {
+ void testDeletePropertyValue() {
ComponentInstanceBusinessLogic testSubject;
ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
createService();
testSubject = createTestSubject();
result = testSubject.deletePropertyValue(componentTypeEnum, serviceId, resourceInstanceId, propertyValueId,
userId);
- Assert.assertNotNull(result);
+ assertNotNull(result);
componentTypeEnum = null;
result = testSubject.deletePropertyValue(componentTypeEnum, serviceId, resourceInstanceId, propertyValueId,
userId);
- Assert.assertNotNull(result);
+ assertNotNull(result);
result = testSubject.deletePropertyValue(componentTypeEnum, serviceId, resourceInstanceId, propertyValueId,
userId);
- Assert.assertNotNull(result);
+ assertNotNull(result);
}
@Test
- public void testGetComponentParametersViewForForwardingPath() throws Exception {
+ void testGetComponentParametersViewForForwardingPath() {
ComponentInstanceBusinessLogic testSubject;
ComponentParametersView result;
// default test
testSubject = createTestSubject();
result = Deencapsulation.invoke(testSubject, "getComponentParametersViewForForwardingPath");
- Assert.assertNotNull(result);
+ assertNotNull(result);
}
@Test
- public void testGetResourceInstanceById() throws Exception {
+ void testGetResourceInstanceById() {
ComponentInstanceBusinessLogic testSubject;
- createResource();
+ resource = createResource();
String instanceId = "";
Either<ComponentInstance, StorageOperationStatus> result;
// default test
testSubject = createTestSubject();
result = Deencapsulation.invoke(testSubject, "getResourceInstanceById", new Object[]{resource, instanceId});
- Assert.assertNotNull(result);
+ assertNotNull(result);
}
@Test
- public void testUpdateInstanceCapabilityProperties_1() throws Exception {
+ void testUpdateInstanceCapabilityProperties_1() {
ComponentInstanceBusinessLogic testSubject;
ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
- createResource();
+ resource = createResource();
String containerComponentId = resource.getUniqueId();
String componentInstanceUniqueId = "";
String capabilityType = "";
testSubject = createTestSubject();
result = testSubject.updateInstanceCapabilityProperties(componentTypeEnum, containerComponentId,
componentInstanceUniqueId, capabilityType, capabilityName, properties, userId);
- Assert.assertNotNull(result);
+ assertNotNull(result);
when(toscaOperationFacade.getToscaFullElement(containerComponentId)).thenReturn(Either.left(resource));
result = testSubject.updateInstanceCapabilityProperties(componentTypeEnum, containerComponentId,
componentInstanceUniqueId, capabilityType, capabilityName, properties, userId);
- Assert.assertNotNull(result);
+ assertNotNull(result);
}
@Test
- public void testCopyComponentInstanceWrongUserId() {
+ void testUpdateInstanceRequirement() {
+ ComponentInstanceBusinessLogic testSubject;
+ ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
+ createComponents();
+ String userId = "userId";
+ resource.setLastUpdaterUserId(userId);
+ String containerComponentId = resource.getUniqueId();
+ String componentInstanceUniqueId = TO_INSTANCE_ID;
+ String capabilityType = "";
+ String capabilityName = "";
+ RequirementDefinition requirementDef = new RequirementDefinition();
+
+ Either<RequirementDefinition, ResponseFormat> result;
+
+ when(toscaOperationFacade.getToscaFullElement(containerComponentId)).thenReturn(Either.left(resource));
+ testSubject = createTestSubject();
+ when(toscaOperationFacade.updateComponentInstanceRequirement(containerComponentId, TO_INSTANCE_ID, requirementDef)).thenReturn(StorageOperationStatus.OK);
+ when(toscaOperationFacade.updateComponentInstanceMetadataOfTopologyTemplate(resource)).thenReturn(Either.left(resource));
+ when(graphLockOperation.unlockComponent(Mockito.anyString(), eq(NodeTypeEnum.Resource)))
+ .thenReturn(StorageOperationStatus.OK);
+ when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Resource)))
+ .thenReturn(StorageOperationStatus.OK);
+
+ result = testSubject.updateInstanceRequirement(componentTypeEnum, containerComponentId,
+ componentInstanceUniqueId, requirementDef, userId);
+ assertEquals(requirementDef, result.left().value());
+
+ }
+
+ @Test
+ void testCopyComponentInstanceWrongUserId() {
Either<Map<String, ComponentInstance>, ResponseFormat> result;
ComponentInstance inputComponentInstance = createComponetInstanceFromComponent(resource);
result = componentInstanceBusinessLogic
.copyComponentInstance(inputComponentInstance, containerComponentId, componentInstanceId,
USER_ID);
- Assert.assertNotNull(result);
+ assertNotNull(result);
service.setLastUpdaterUserId(oldLastUpdatedUserId);
- assertThat(result.isRight());
+ assertThat(result.isRight()).isTrue();
}
@Test
- public void testCopyComponentInstanceComponentWrongState() {
+ void testCopyComponentInstanceComponentWrongState() {
Either<Map<String, ComponentInstance>, ResponseFormat> result;
ComponentInstance inputComponentInstance = createComponetInstanceFromComponent(resource);
String containerComponentId = service.getUniqueId();
.thenReturn(StorageOperationStatus.OK);
when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Service)))
.thenReturn(StorageOperationStatus.OK);
- Either<Component, StorageOperationStatus> getComponentRes = Either.left(resource);
result = componentInstanceBusinessLogic
.copyComponentInstance(inputComponentInstance, containerComponentId, componentInstanceId, USER_ID);
- Assert.assertNotNull(result);
+ assertNotNull(result);
service.setLastUpdaterUserId(oldServiceLastUpdatedUserId);
- assertThat(result.isRight());
+ assertThat(result.isRight()).isTrue();
}
@Test
- public void testCopyComponentInstance() {
+ void testCopyComponentInstance() {
Either<Map<String, ComponentInstance>, ResponseFormat> result;
ComponentInstance inputComponentInstance = createComponetInstanceFromComponent(resource);
String containerComponentId = service.getUniqueId();
.thenReturn(StorageOperationStatus.OK);
when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Service)))
.thenReturn(StorageOperationStatus.OK);
- Either<Component, StorageOperationStatus> getComponentRes = Either.left(resource);
- ImmutablePair<Component, String> pair = new ImmutablePair<>(resource, TO_INSTANCE_ID);
- Either<ImmutablePair<Component, String>, StorageOperationStatus> result2 = Either.left(pair);
- Either<Map<String, ArtifactDefinition>, StorageOperationStatus> getResourceDeploymentArtifacts = Either
- .left(new HashMap<String, ArtifactDefinition>());
- StorageOperationStatus artStatus = StorageOperationStatus.OK;
result = componentInstanceBusinessLogic
.copyComponentInstance(inputComponentInstance, containerComponentId, componentInstanceId,
USER_ID);
- Assert.assertNotNull(result);
+ assertNotNull(result);
service.setLastUpdaterUserId(oldServiceLastUpdatedUserId);
resource.setLifecycleState(oldResourceLifeCycle);
- assertThat(result.isLeft());
+ assertThat(result.isLeft()).isFalse();
}
@Test
- public void testCreateOrUpdateAttributeValueForCopyPaste() {
+ void testCreateOrUpdateAttributeValueForCopyPaste() {
ComponentInstance serviceComponentInstance = createComponetInstanceFromComponent(service);
- ComponentInstanceProperty attribute = new ComponentInstanceProperty();
+ ComponentInstanceAttribute attribute = new ComponentInstanceAttribute();
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<String, List<ComponentInstanceProperty>> instAttrsMap =
- new HashMap<String, List<ComponentInstanceProperty>>();
- List<ComponentInstanceProperty> instAttrsList = new ArrayList<ComponentInstanceProperty>();
- ComponentInstanceProperty prop = new ComponentInstanceProperty();
+ Map<String, List<ComponentInstanceAttribute>> instAttrsMap = new HashMap<>();
+ List<ComponentInstanceAttribute> instAttrsList = new ArrayList<>();
+ ComponentInstanceAttribute prop = new ComponentInstanceAttribute();
prop.setUniqueId(attribute.getUniqueId());
instAttrsList.add(prop);
instAttrsMap.put(toInstance.getUniqueId(), instAttrsList);
when(toscaOperationFacade.updateComponentInstanceMetadataOfTopologyTemplate(service))
.thenReturn(serviceEitherLeft);
- Either<ComponentInstanceProperty, ResponseFormat> result = Deencapsulation
+ Either<ComponentInstanceAttribute, ResponseFormat> result = Deencapsulation
.invoke(componentInstanceBusinessLogic,
"createOrUpdateAttributeValueForCopyPaste",
ComponentTypeEnum.SERVICE,
.getUniqueId(),
toInstance.getUniqueId(), attribute,
USER_ID);
- Assert.assertNotNull(result);
+ assertNotNull(result);
service.setLastUpdaterUserId(oldLastUpdatedUserId);
service.setLifecycleState(oldLifeCycleState);
- assertTrue(result.isLeft());
- ComponentInstanceProperty resultProp = result.left().value();
- assertEquals(resultProp.getPath().size(), 1);
+ assertThat(result.isLeft()).isTrue();
+ ComponentInstanceAttribute resultProp = result.left().value();
+ assertEquals(1, resultProp.getPath().size());
assertEquals(resultProp.getPath().get(0), toInstance.getUniqueId());
}
@Test
- public void testUpdateComponentInstanceProperty() {
+ void testUpdateComponentInstanceProperty() {
String containerComponentId = service.getUniqueId();
String componentInstanceId = "dummy_id";
Either<String, ResponseFormat> result = Deencapsulation.invoke(componentInstanceBusinessLogic,
"updateComponentInstanceProperty", containerComponentId, componentInstanceId, property);
- Assert.assertNotNull(result);
- assertTrue(result.isLeft());
+ assertNotNull(result);
+ assertThat(result.isLeft()).isTrue();
}
@Test
- public void testGetInputListDefaultValue() {
+ void testGetInputListDefaultValue() {
Component component = service;
String inputId = "dummy_id";
String defaultValue = "dummy_default_value";
- List<InputDefinition> newInputs = new ArrayList<InputDefinition>();
+ List<InputDefinition> newInputs = new ArrayList<>();
InputDefinition in = new InputDefinition();
in.setUniqueId(inputId);
in.setDefaultValue(defaultValue);
}
@Test
- public void testBatchDeleteComponentInstanceFailureWrongType() {
+ 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);
Either<Component, StorageOperationStatus> cont = Either.left(service);
- when(componentsUtils.convertFromStorageResponse(eq(StorageOperationStatus.NOT_FOUND), eq(null)))
+ when(componentsUtils.convertFromStorageResponse(StorageOperationStatus.NOT_FOUND, null))
.thenReturn(ActionStatus.GENERAL_ERROR);
when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
.thenReturn(cont);
try {
result = componentInstanceBusinessLogic
.batchDeleteComponentInstance(containerComponentParam, containerComponentId, componentInstanceIdList,
- userId);
- Assert.assertNotNull(result);
+ USER_ID);
+ assertNotNull(result);
assertEquals(deleteErrorMap, result);
} catch (ComponentException e) {
assertEquals(e.getActionStatus().toString(), StorageOperationStatus.GENERAL_ERROR.toString());
}
@Test
- public void testBatchDeleteComponentInstanceFailureCompIds() {
- Map<String, List<String>> result = new HashMap<>();
+ void testBatchDeleteComponentInstanceFailureCompIds() {
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);
.thenReturn(err);
try {
- result = componentInstanceBusinessLogic
- .batchDeleteComponentInstance(containerComponentParam, containerComponentId, componentInstanceIdList,
- userId);
- Assert.assertNotNull(result);
+ Map<String, List<String>> 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
- public void testBatchDeleteComponentInstanceSuccess() {
+ void testBatchDeleteComponentInstanceSuccess() {
Map<String, List<String>> result;
String containerComponentParam = ComponentTypeEnum.SERVICE_PARAM_NAME;
LifecycleStateEnum oldLifeCycleState = service.getLifecycleState();
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<>();
result = componentInstanceBusinessLogic
.batchDeleteComponentInstance(containerComponentParam, containerComponentId,
- componentInstanceIdList, userId);
- Assert.assertNotNull(result);
+ componentInstanceIdList, USER_ID);
+ assertNotNull(result);
service.setLastUpdaterUserId(oldLastUpdatedUserId);
service.setLifecycleState(oldLifeCycleState);
}
@Test
- public void testDissociateRIFromRIFailDissociate() {
+ void testDissociateRIFromRIFailDissociate() {
List<RequirementCapabilityRelDef> result;
RequirementCapabilityRelDef ref = new RequirementCapabilityRelDef();
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);
.thenReturn(StorageOperationStatus.OK);
Either<RequirementCapabilityRelDef, StorageOperationStatus> resultEither;
resultEither = Either.right(StorageOperationStatus.OK);
- when(componentsUtils.convertFromStorageResponseForResourceInstance(eq(StorageOperationStatus.OK), eq(true)))
+ when(componentsUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.OK, true))
.thenReturn(ActionStatus.GENERAL_ERROR);
when(toscaOperationFacade.dissociateResourceInstances(componentId, ref)).thenReturn(resultEither);
try {
result = componentInstanceBusinessLogic
- .batchDissociateRIFromRI(componentId, userId, requirementDefList, componentTypeEnum);
- Assert.assertNotNull(result);
+ .batchDissociateRIFromRI(componentId, USER_ID, requirementDefList, componentTypeEnum);
+ assertNotNull(result);
assertEquals(new ArrayList<>(), result);
} catch (ComponentException e) {
assertEquals(e.getActionStatus().toString(), StorageOperationStatus.GENERAL_ERROR.toString());
}
@Test
- public void testDissociateRIFromRISuccess() {
+ void testDissociateRIFromRISuccess() {
List<RequirementCapabilityRelDef> result;
RequirementCapabilityRelDef ref = new RequirementCapabilityRelDef();
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);
when(toscaOperationFacade.dissociateResourceInstances(componentId, ref)).thenReturn(resultEither);
result = componentInstanceBusinessLogic
- .batchDissociateRIFromRI(componentId, userId, requirementDefList, componentTypeEnum);
- Assert.assertNotNull(result);
+ .batchDissociateRIFromRI(componentId, USER_ID, requirementDefList, componentTypeEnum);
+ assertNotNull(result);
service.setLastUpdaterUserId(oldLastUpdatedUserId);
service.setLifecycleState(oldLifeCycleState);
}
@Test
- public void testGetComponentInstancePropertyByPolicyId_success() {
+ void testGetComponentInstancePropertyByPolicyId_success() {
Optional<ComponentInstanceProperty> propertyCandidate =
getComponentInstanceProperty(PROP_NAME);
- Assert.assertTrue(propertyCandidate.isPresent());
- Assert.assertEquals(propertyCandidate.get().getName(), PROP_NAME);
+ assertThat(propertyCandidate).isPresent();
+ assertEquals(PROP_NAME, propertyCandidate.get().getName());
}
@Test
- public void testGetComponentInstancePropertyByPolicyId_failure() {
+ void testGetComponentInstancePropertyByPolicyId_failure() {
Optional<ComponentInstanceProperty> propertyCandidate =
getComponentInstanceProperty(NON_EXIST_NAME);
- Assert.assertEquals(propertyCandidate, Optional.empty());
+ assertEquals(propertyCandidate, Optional.empty());
}
private Optional<ComponentInstanceProperty> getComponentInstanceProperty(String propertyName) {
componentInstanceProperty.setGetPolicyValues(policyDefinition.getGetPolicyValues());
service.setComponentInstancesProperties(
- Collections.singletonMap(COMPONENT_INST_ID, Collections.singletonList(componentInstanceProperty)));
+ Collections.singletonMap(COMPONENT_INSTANCE_ID, Collections.singletonList(componentInstanceProperty)));
return componentInstanceBusinessLogic.getComponentInstancePropertyByPolicyId(service, policyDefinition);
}
private PolicyDefinition getPolicyDefinition() {
PolicyDefinition policyDefinition = new PolicyDefinition();
- policyDefinition.setInstanceUniqueId(COMPONENT_INST_ID);
+ policyDefinition.setInstanceUniqueId(COMPONENT_INSTANCE_ID);
policyDefinition.setName(PROP_NAME);
GetPolicyValueDataDefinition getPolicy = new GetPolicyValueDataDefinition();
componentInst.setDeploymentArtifacts(component.getDeploymentArtifacts());
return componentInst;
}
+
+ // Prepare ComponentInstance & Resource objects used in createComponentInstance() tests
+
+ private Pair<ComponentInstance, Resource> 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<DynamicTest> 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(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<ComponentInstance, Resource> 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(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<ComponentInstance, Resource> 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(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<ComponentInstance, Resource> 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(ORIGIN_COMPONENT_ID))
+ .thenReturn(Either.left(originComponent));
+
+ final 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() {
+ final Pair<ComponentInstance, Resource> p = prepareResourcesForCreateComponentInstanceTest();
+ final ComponentInstance ci = p.getLeft();
+ final Resource originComponent = p.getRight();
+
+ // Stub for getting component
+ when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class)))
+ .thenReturn(Either.left(service));
+ when(toscaOperationFacade.getToscaFullElement(ORIGIN_COMPONENT_ID))
+ .thenReturn(Either.left(originComponent));
+ // Assume services cannot contain VF resource
+ when(containerInstanceTypeData.isAllowedForServiceComponent(ResourceTypeEnum.VF, null))
+ .thenReturn(false);
+
+ ByActionStatusComponentException actualException = assertThrows(ByActionStatusComponentException.class, () -> {
+ componentInstanceBusinessLogic.createComponentInstance(ComponentTypeEnum.SERVICE_PARAM_NAME, COMPONENT_ID, USER_ID, ci);
+ });
+ assertThat(actualException.getActionStatus()).isEqualTo(ActionStatus.CONTAINER_CANNOT_CONTAIN_INSTANCE);
+ verify(containerInstanceTypeData, times(1)).isAllowedForServiceComponent(ResourceTypeEnum.VF, null);
+
+ //given
+ final Resource resource = createResource();
+ resource.setResourceType(ResourceTypeEnum.VF);
+ resource.setLastUpdaterUserId(USER_ID);
+ //when
+ when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class)))
+ .thenReturn(Either.left(resource));
+ when(toscaOperationFacade.getToscaFullElement(ORIGIN_COMPONENT_ID))
+ .thenReturn(Either.left(originComponent));
+ when(containerInstanceTypeData.isAllowedForResourceComponent(ResourceTypeEnum.VF, ResourceTypeEnum.VF))
+ .thenReturn(false);
+ actualException = assertThrows(ByActionStatusComponentException.class, () -> {
+ componentInstanceBusinessLogic.createComponentInstance(RESOURCE_PARAM_NAME, COMPONENT_ID, USER_ID, ci);
+ });
+ //then
+ assertThat(actualException.getActionStatus()).isEqualTo(ActionStatus.CONTAINER_CANNOT_CONTAIN_INSTANCE);
+ }
+
+ @Test
+ void testCreateComponentInstanceFailureAddToGraph() {
+ final Pair<ComponentInstance, Resource> p = prepareResourcesForCreateComponentInstanceTest();
+ final ComponentInstance ci = p.getLeft();
+ final 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(ORIGIN_COMPONENT_ID))
+ .thenReturn(Either.left(originComponent));
+ when(containerInstanceTypeData.isAllowedForServiceComponent(ResourceTypeEnum.VF, null))
+ .thenReturn(true);
+ 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))
+ .isAllowedForServiceComponent(ResourceTypeEnum.VF, null);
+ 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() {
+ final Pair<ComponentInstance, Resource> p = prepareResourcesForCreateComponentInstanceTest();
+ final ComponentInstance instanceToBeCreated = p.getLeft();
+ final Resource originComponent = p.getRight();
+
+ final 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(ORIGIN_COMPONENT_ID))
+ .thenReturn(Either.left(originComponent));
+ when(containerInstanceTypeData.isAllowedForServiceComponent(ResourceTypeEnum.VF, null))
+ .thenReturn(true);
+ 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);
+
+ final 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))
+ .isAllowedForServiceComponent(ResourceTypeEnum.VF, null);
+ 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();
+ }
+
+ @Test
+ void testCreateComponentInstanceServiceSubstitutionSuccess() {
+ ComponentInstance instanceToBeCreated = createServiceSubstitutionComponentInstance();
+ Service originService = createServiceSubstitutionOriginService();
+ Component serviceBaseComponent = createServiceSubstitutionServiceDerivedFromComponent();
+
+ Service updatedService = new Service();
+ updatedService.setComponentInstances(Collections.singletonList(instanceToBeCreated));
+ updatedService.setUniqueId(service.getUniqueId());
+
+ when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class)))
+ .thenReturn(Either.left(service));
+ when(toscaOperationFacade.getToscaFullElement(ORIGIN_COMPONENT_ID))
+ .thenReturn(Either.left(originService));
+ when(toscaOperationFacade.getLatestByToscaResourceName(eq(originService.getDerivedFromGenericType()), isNull()))
+ .thenReturn(Either.left(serviceBaseComponent));
+ when(toscaOperationFacade.getToscaElement(eq(ORIGIN_COMPONENT_ID), any(ComponentParametersView.class)))
+ .thenReturn(Either.left(originService));
+ Mockito.doNothing().when(compositionBusinessLogic).validateAndSetDefaultCoordinates(instanceToBeCreated);
+ when(graphLockOperation.lockComponent(COMPONENT_ID, NodeTypeEnum.Service))
+ .thenReturn(StorageOperationStatus.OK);
+ when(toscaOperationFacade.addComponentInstanceToTopologyTemplate(service, serviceBaseComponent, instanceToBeCreated, false, user))
+ .thenReturn(Either.left(new ImmutablePair<>(updatedService, COMPONENT_INSTANCE_ID)));
+ when(artifactsBusinessLogic.getArtifacts(
+ "baseComponentId", NodeTypeEnum.Resource, ArtifactGroupTypeEnum.DEPLOYMENT, null))
+ .thenReturn(Either.left(new HashMap<>()));
+ when(toscaOperationFacade
+ .addInformationalArtifactsToInstance(service.getUniqueId(), instanceToBeCreated, originService.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(originService.getVersion());
+ assertThat(instanceToBeCreated.getIcon()).isEqualTo(originService.getIcon());
+ verify(compositionBusinessLogic, times(1)).validateAndSetDefaultCoordinates(instanceToBeCreated);
+ verify(toscaOperationFacade, times(1))
+ .addComponentInstanceToTopologyTemplate(service, serviceBaseComponent, instanceToBeCreated, false, user);
+ // Check graph db change was committed
+ verify(janusGraphDao, times(1)).commit();
+ }
+
+ @Test
+ void testGetComponentInstanceAttributesById_success() {
+ final ComponentInstanceAttribute componentInstanceAttribute = new ComponentInstanceAttribute();
+ componentInstanceAttribute.setComponentInstanceId(TO_INSTANCE_ID);
+
+ final HashMap<String, List<ComponentInstanceAttribute>> map = new HashMap<>();
+ map.put(TO_INSTANCE_ID, Arrays.asList(componentInstanceAttribute));
+ resource.setComponentInstancesAttributes(map);
+
+ final Either<Component, StorageOperationStatus> leftServiceOp = Either.left(resource);
+ doReturn(leftServiceOp).when(toscaOperationFacade).getToscaElement(COMPONENT_ID);
+
+ final List<ComponentInstanceAttribute> result = componentInstanceBusinessLogic
+ .getComponentInstanceAttributesById(RESOURCE_PARAM_NAME, COMPONENT_ID, TO_INSTANCE_ID, USER_ID);
+ assertThat(result).isNotNull().isNotEmpty();
+ verify(toscaOperationFacade, times(1)).getToscaElement(COMPONENT_ID);
+ }
+
+ @Test
+ void testGetComponentInstanceAttributesById_fail_missing_ComponentInstancesAttributes() {
+ final Either<Component, StorageOperationStatus> leftServiceOp = Either.left(resource);
+ doReturn(leftServiceOp).when(toscaOperationFacade).getToscaElement(COMPONENT_ID);
+
+ final List<ComponentInstanceAttribute> result = componentInstanceBusinessLogic
+ .getComponentInstanceAttributesById(RESOURCE_PARAM_NAME, COMPONENT_ID, TO_INSTANCE_ID, USER_ID);
+ assertThat(result).isNotNull().isEmpty();
+ verify(toscaOperationFacade, times(1)).getToscaElement(COMPONENT_ID);
+ }
+
+ @Test
+ void testGetComponentInstanceAttributesById_fail_getToscaElement() {
+ final ComponentInstanceAttribute componentInstanceAttribute = new ComponentInstanceAttribute();
+ componentInstanceAttribute.setComponentInstanceId(TO_INSTANCE_ID);
+
+ final HashMap<String, List<ComponentInstanceAttribute>> map = new HashMap<>();
+ map.put(TO_INSTANCE_ID, Arrays.asList(componentInstanceAttribute));
+ resource.setComponentInstancesAttributes(map);
+
+ final Either<Object, StorageOperationStatus> right = Either.right(StorageOperationStatus.BAD_REQUEST);
+ doReturn(right).when(toscaOperationFacade).getToscaElement(COMPONENT_ID);
+ doReturn(ActionStatus.BAD_REQUEST_MISSING_RESOURCE).when(componentsUtils).convertFromStorageResponse(StorageOperationStatus.BAD_REQUEST);
+
+ assertThrows(ByActionStatusComponentException.class, () -> {
+ final List<ComponentInstanceAttribute> result = componentInstanceBusinessLogic
+ .getComponentInstanceAttributesById(RESOURCE_PARAM_NAME, COMPONENT_ID, TO_INSTANCE_ID, USER_ID);
+
+ });
+
+ }
+
+ @Test
+ void testGetComponentInstanceAttributesById_fail_getResourceInstanceById() {
+ final ComponentInstanceAttribute componentInstanceAttribute = new ComponentInstanceAttribute();
+ componentInstanceAttribute.setComponentInstanceId(TO_INSTANCE_ID);
+
+ final HashMap<String, List<ComponentInstanceAttribute>> map = new HashMap<>();
+ map.put(TO_INSTANCE_ID, Arrays.asList(componentInstanceAttribute));
+ resource.setComponentInstancesAttributes(map);
+
+ final Either<Component, StorageOperationStatus> leftServiceOp = Either.left(resource);
+ doReturn(leftServiceOp).when(toscaOperationFacade).getToscaElement(COMPONENT_ID);
+ doReturn(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE).when(componentsUtils).convertFromStorageResponse(StorageOperationStatus.PARENT_RESOURCE_NOT_FOUND);
+
+ assertThrows(ByActionStatusComponentException.class, () -> {
+ final List<ComponentInstanceAttribute> result = componentInstanceBusinessLogic
+ .getComponentInstanceAttributesById(RESOURCE_PARAM_NAME, COMPONENT_ID, "", USER_ID);
+
+ });
+
+ }
+
+ @Test
+ void updateInstanceCapabilitySuccessTest() {
+ var containerComponentId = "containerComponentId";
+ var componentInstanceUniqueId = "componentInstanceUniqueId";
+ var capabilityDefinition = new CapabilityDefinition();
+ capabilityDefinition.setUniqueId("uniqueId");
+
+ final Component component = new Service();
+ component.setUniqueId(containerComponentId);
+ component.setLastUpdaterUserId(USER_ID);
+ component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+
+ var componentInstance = new ComponentInstance();
+ componentInstance.setUniqueId(componentInstanceUniqueId);
+ component.setComponentInstances(Collections.singletonList(componentInstance));
+
+ when(toscaOperationFacade.getToscaFullElement(containerComponentId))
+ .thenReturn(Either.left(component));
+ when(toscaOperationFacade.updateComponentInstanceCapability(containerComponentId, componentInstanceUniqueId, capabilityDefinition))
+ .thenReturn(capabilityDefinition);
+ when(toscaOperationFacade.updateComponentInstanceMetadataOfTopologyTemplate(component))
+ .thenReturn(Either.left(component));
+ when(graphLockOperation.lockComponent(containerComponentId, NodeTypeEnum.Service))
+ .thenReturn(StorageOperationStatus.OK);
+
+ final Either<CapabilityDefinition, ResponseFormat> resultEither = componentInstanceBusinessLogic
+ .updateInstanceCapability(ComponentTypeEnum.SERVICE, containerComponentId, componentInstanceUniqueId, capabilityDefinition, USER_ID);
+ assertTrue(resultEither.isLeft());
+ final CapabilityDefinition actualCapabilityDefinition = resultEither.left().value();
+ assertNotEquals(capabilityDefinition, actualCapabilityDefinition);
+ assertEquals(capabilityDefinition.getUniqueId(), actualCapabilityDefinition.getUniqueId());
+ }
+
+ @Test
+ void updateInstanceCapabilityNoContainerComponentTypeTest() {
+ var responseFormat = new ResponseFormat();
+ when(componentsUtils.getResponseFormat(ActionStatus.NOT_ALLOWED)).thenReturn(responseFormat);
+ final Either<CapabilityDefinition, ResponseFormat> resultEither = componentInstanceBusinessLogic
+ .updateInstanceCapability(null, "containerComponentId", "componentInstanceUniqueId", new CapabilityDefinition(), USER_ID);
+ assertTrue(resultEither.isRight(), "Either return should be right");
+ final ResponseFormat actualResponseFormat = resultEither.right().value();
+ assertEquals(responseFormat, actualResponseFormat);
+ }
+
+ @Test
+ void updateInstanceCapabilityContainerComponentNotFoundTest() {
+ var containerComponentId = "containerComponentId";
+ when(toscaOperationFacade.getToscaFullElement(containerComponentId)).thenReturn(Either.right(null));
+ var responseFormat = new ResponseFormat();
+ when(componentsUtils.getResponseFormat(ActionStatus.COMPONENT_NOT_FOUND, containerComponentId)).thenReturn(responseFormat);
+ final Either<CapabilityDefinition, ResponseFormat> resultEither = componentInstanceBusinessLogic
+ .updateInstanceCapability(ComponentTypeEnum.SERVICE, "containerComponentId", "componentInstanceUniqueId", new CapabilityDefinition(), USER_ID);
+ assertTrue(resultEither.isRight(), "Either return should be right");
+ final ResponseFormat actualResponseFormat = resultEither.right().value();
+ assertEquals(responseFormat, actualResponseFormat);
+ }
+
+ @Test
+ void updateInstanceCapabilityCannotWorkOnComponentTest() {
+ var containerComponentId = "containerComponentId";
+ var componentInstanceUniqueId = "componentInstanceUniqueId";
+
+ final Component component = new Service();
+ component.setUniqueId(containerComponentId);
+ component.setLastUpdaterUserId("anotherUse");
+ component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+
+ var expectedResponseFormat = new ResponseFormat();
+
+ when(toscaOperationFacade.getToscaFullElement(containerComponentId))
+ .thenReturn(Either.left(component));
+ when(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION))
+ .thenReturn(expectedResponseFormat);
+
+ final Either<CapabilityDefinition, ResponseFormat> resultEither = componentInstanceBusinessLogic
+ .updateInstanceCapability(ComponentTypeEnum.SERVICE, containerComponentId, componentInstanceUniqueId, new CapabilityDefinition(), USER_ID);
+ assertTrue(resultEither.isRight(), "Either return should be right");
+ final ResponseFormat actualResponseFormat = resultEither.right().value();
+ assertEquals(expectedResponseFormat, actualResponseFormat);
+ }
+
+ @Test
+ void updateInstanceCapabilityResourceInstanceNotFoundTest() {
+ var containerComponentId = "containerComponentId";
+ var componentInstanceUniqueId = "componentInstanceUniqueId";
+
+ final Component component = new Service();
+ component.setUniqueId(containerComponentId);
+ component.setLastUpdaterUserId(USER_ID);
+ component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+
+ var expectedResponseFormat = new ResponseFormat();
+
+ when(toscaOperationFacade.getToscaFullElement(containerComponentId))
+ .thenReturn(Either.left(component));
+ when(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND_ON_SERVICE, componentInstanceUniqueId, containerComponentId))
+ .thenReturn(expectedResponseFormat);
+
+ final Either<CapabilityDefinition, ResponseFormat> resultEither = componentInstanceBusinessLogic
+ .updateInstanceCapability(ComponentTypeEnum.SERVICE, containerComponentId, componentInstanceUniqueId, new CapabilityDefinition(), USER_ID);
+ assertTrue(resultEither.isRight(), "Either return should be right");
+ final ResponseFormat actualResponseFormat = resultEither.right().value();
+ assertEquals(expectedResponseFormat, actualResponseFormat);
+ }
+
+ @Test
+ void updateInstanceCapabilityUpdateMetadataFailTest() {
+ var containerComponentId = "containerComponentId";
+ var componentInstanceUniqueId = "componentInstanceUniqueId";
+ var capabilityDefinition = new CapabilityDefinition();
+ capabilityDefinition.setUniqueId("uniqueId");
+
+ final Component component = new Service();
+ component.setUniqueId(containerComponentId);
+ component.setLastUpdaterUserId(USER_ID);
+ component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+
+ var componentInstance = new ComponentInstance();
+ componentInstance.setUniqueId(componentInstanceUniqueId);
+ component.setComponentInstances(Collections.singletonList(componentInstance));
+
+ var expectedResponseFormat = new ResponseFormat();
+
+ when(toscaOperationFacade.getToscaFullElement(containerComponentId))
+ .thenReturn(Either.left(component));
+ when(graphLockOperation.lockComponent(containerComponentId, NodeTypeEnum.Service))
+ .thenReturn(StorageOperationStatus.OK);
+ when(toscaOperationFacade.updateComponentInstanceCapability(containerComponentId, componentInstanceUniqueId, capabilityDefinition))
+ .thenReturn(capabilityDefinition);
+ when(toscaOperationFacade.updateComponentInstanceMetadataOfTopologyTemplate(component))
+ .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
+ when(componentsUtils.convertFromStorageResponse(StorageOperationStatus.GENERAL_ERROR, ComponentTypeEnum.SERVICE))
+ .thenReturn(ActionStatus.GENERAL_ERROR);
+ when(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR))
+ .thenReturn(expectedResponseFormat);
+
+ final Either<CapabilityDefinition, ResponseFormat> resultEither = componentInstanceBusinessLogic
+ .updateInstanceCapability(ComponentTypeEnum.SERVICE, containerComponentId, componentInstanceUniqueId, capabilityDefinition, USER_ID);
+ assertTrue(resultEither.isRight(), "Either return should be right");
+ final ResponseFormat actualResponseFormat = resultEither.right().value();
+ assertEquals(expectedResponseFormat, actualResponseFormat);
+ }
+
+ @Test
+ void updateInstanceCapabilityBusinessExceptionHandlingTest() {
+ var containerComponentId = "containerComponentId";
+ var componentInstanceUniqueId = "componentInstanceUniqueId";
+ var capabilityDefinition = new CapabilityDefinition();
+ capabilityDefinition.setUniqueId("uniqueId");
+
+ final Component component = new Service();
+ component.setUniqueId(containerComponentId);
+ component.setLastUpdaterUserId(USER_ID);
+ component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+
+ var componentInstance = new ComponentInstance();
+ componentInstance.setUniqueId(componentInstanceUniqueId);
+ component.setComponentInstances(Collections.singletonList(componentInstance));
+
+
+ when(toscaOperationFacade.getToscaFullElement(containerComponentId))
+ .thenReturn(Either.left(component));
+ when(graphLockOperation.lockComponent(containerComponentId, NodeTypeEnum.Service))
+ .thenReturn(StorageOperationStatus.OK);
+ when(toscaOperationFacade.updateComponentInstanceCapability(containerComponentId, componentInstanceUniqueId, capabilityDefinition))
+ .thenThrow(new OperationException(ActionStatus.GENERAL_ERROR));
+
+ final BusinessException businessException = assertThrows(BusinessException.class, () -> {
+ componentInstanceBusinessLogic
+ .updateInstanceCapability(ComponentTypeEnum.SERVICE, containerComponentId, componentInstanceUniqueId, capabilityDefinition, USER_ID);
+ });
+ assertTrue(businessException instanceof OperationException);
+ assertEquals(ActionStatus.GENERAL_ERROR, ((OperationException) businessException).getActionStatus());
+ }
+
+ @Test
+ void updateInstanceCapabilityUnknownExceptionHandlingTest() {
+ var containerComponentId = "containerComponentId";
+ var componentInstanceUniqueId = "componentInstanceUniqueId";
+ var capabilityDefinition = new CapabilityDefinition();
+ capabilityDefinition.setUniqueId("uniqueId");
+
+ final Component component = new Service();
+ component.setUniqueId(containerComponentId);
+ component.setLastUpdaterUserId(USER_ID);
+ component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+
+ var componentInstance = new ComponentInstance();
+ componentInstance.setUniqueId(componentInstanceUniqueId);
+ component.setComponentInstances(Collections.singletonList(componentInstance));
+
+ var expectedResponseFormat = new ResponseFormat();
+
+ when(toscaOperationFacade.getToscaFullElement(containerComponentId))
+ .thenReturn(Either.left(component));
+ when(graphLockOperation.lockComponent(containerComponentId, NodeTypeEnum.Service))
+ .thenReturn(StorageOperationStatus.OK);
+ when(toscaOperationFacade.updateComponentInstanceCapability(containerComponentId, componentInstanceUniqueId, capabilityDefinition))
+ .thenThrow(new RuntimeException());
+ when(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR))
+ .thenReturn(expectedResponseFormat);
+
+ final Exception exception = assertThrows(BusinessException.class, () ->
+ componentInstanceBusinessLogic
+ .updateInstanceCapability(ComponentTypeEnum.SERVICE, containerComponentId, componentInstanceUniqueId, capabilityDefinition, USER_ID));
+ assertTrue(exception instanceof ByResponseFormatComponentException);
+ final ByResponseFormatComponentException actualException = (ByResponseFormatComponentException) exception;
+ assertEquals(expectedResponseFormat, actualException.getResponseFormat());
+ }
+
+ private ComponentInstance createServiceSubstitutionComponentInstance() {
+ final ComponentInstance instanceToBeCreated = new ComponentInstance();
+ instanceToBeCreated.setName(COMPONENT_INSTANCE_NAME);
+ instanceToBeCreated.setUniqueId(COMPONENT_INSTANCE_ID);
+ instanceToBeCreated.setComponentUid(ORIGIN_COMPONENT_ID);
+ instanceToBeCreated.setOriginType(OriginTypeEnum.ServiceSubstitution);
+
+ return instanceToBeCreated;
+ }
+
+ private Service createServiceSubstitutionOriginService() {
+ final Service originComponent = new Service();
+ originComponent.setLifecycleState(LifecycleStateEnum.CERTIFIED);
+ originComponent.setVersion(ORIGIN_COMPONENT_VERSION);
+ originComponent.setIcon(ICON_NAME);
+ originComponent.setDerivedFromGenericType("org.openecomp.resource.abstract.nodes.service");
+ originComponent.setName("myService");
+ return originComponent;
+ }
+
+ private Component createServiceSubstitutionServiceDerivedFromComponent() {
+ final Resource component = new Resource();
+ component.setLifecycleState(LifecycleStateEnum.CERTIFIED);
+ component.setVersion(ORIGIN_COMPONENT_VERSION);
+ component.setIcon(ICON_NAME);
+ component.setToscaResourceName("org.openecomp.resource.abstract.nodes.service");
+ component.setUniqueId("baseComponentId");
+ return component;
+ }
+
+ private void mockComponentForToscaGetFunctionValidation(final Component component) {
+ when(toscaOperationFacade.getToscaElement(component.getUniqueId(), JsonParseFlagEnum.ParseAll))
+ .thenReturn(Either.left(component));
+ when(graphLockOperation.lockComponent(component.getUniqueId(), NodeTypeEnum.ResourceInstance))
+ .thenReturn(StorageOperationStatus.OK);
+ when(toscaOperationFacade.updateComponentInstanceMetadataOfTopologyTemplate(component))
+ .thenReturn(Either.left(component));
+ when(janusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
+ when(graphLockOperation.unlockComponent(component.getUniqueId(), NodeTypeEnum.ResourceInstance))
+ .thenReturn(StorageOperationStatus.OK);
+ }
+
+ private ToscaGetFunctionDataDefinition createGetToscaFunction(final String propertyName, final String propertyUniqueId,
+ final List<String> propertyPathFromSource,
+ final PropertySource propertySource, final ToscaGetFunctionType functionType,
+ final String sourceUniqueId,
+ final String sourceName) {
+ final var toscaGetFunction = new ToscaGetFunctionDataDefinition();
+ toscaGetFunction.setFunctionType(functionType);
+ toscaGetFunction.setPropertyUniqueId(propertyUniqueId);
+ toscaGetFunction.setPropertyName(propertyName);
+ toscaGetFunction.setPropertyPathFromSource(propertyPathFromSource);
+ toscaGetFunction.setPropertySource(propertySource);
+ toscaGetFunction.setSourceName(sourceName);
+ toscaGetFunction.setSourceUniqueId(sourceUniqueId);
+ return toscaGetFunction;
+ }
+
+ private SchemaDefinition createSchema(final String schemaType) {
+ final var schemaDefinition = new SchemaDefinition();
+ final var schemaProperty = new PropertyDefinition();
+ schemaProperty.setType(schemaType);
+ schemaDefinition.setProperty(schemaProperty);
+ return schemaDefinition;
+ }
+
+ private static Stream<Arguments> getToscaFunctionForValidation() {
+ final var toscaGetFunction1 = new ToscaGetFunctionDataDefinition();
+ final ResponseFormat expectedResponse1 = ToscaFunctionExceptionSupplier
+ .missingFunctionType().get().getResponseFormat();
+
+ final var toscaGetFunction2 = new ToscaGetFunctionDataDefinition();
+ toscaGetFunction2.setFunctionType(ToscaGetFunctionType.GET_INPUT);
+ final ResponseFormat expectedResponse2 = ToscaGetFunctionExceptionSupplier
+ .targetPropertySourceNotFound(toscaGetFunction2.getFunctionType()).get().getResponseFormat();
+
+ final var toscaGetFunction3 = new ToscaGetFunctionDataDefinition();
+ toscaGetFunction3.setFunctionType(ToscaGetFunctionType.GET_INPUT);
+ toscaGetFunction3.setPropertySource(PropertySource.SELF);
+ final ResponseFormat expectedResponse3 = ToscaGetFunctionExceptionSupplier
+ .targetSourcePathNotFound(toscaGetFunction3.getFunctionType()).get().getResponseFormat();
+
+ final var toscaGetFunction4 = new ToscaGetFunctionDataDefinition();
+ toscaGetFunction4.setFunctionType(ToscaGetFunctionType.GET_INPUT);
+ toscaGetFunction4.setPropertySource(PropertySource.SELF);
+ toscaGetFunction4.setPropertyPathFromSource(List.of("sourcePath"));
+ final ResponseFormat expectedResponse4 = ToscaGetFunctionExceptionSupplier
+ .sourceNameNotFound(toscaGetFunction4.getPropertySource()).get().getResponseFormat();
+
+ final var toscaGetFunction5 = new ToscaGetFunctionDataDefinition();
+ toscaGetFunction5.setFunctionType(ToscaGetFunctionType.GET_INPUT);
+ toscaGetFunction5.setPropertySource(PropertySource.SELF);
+ toscaGetFunction5.setPropertyPathFromSource(List.of("sourcePath"));
+ toscaGetFunction5.setSourceName("sourceName");
+ final ResponseFormat expectedResponse5 = ToscaGetFunctionExceptionSupplier
+ .sourceIdNotFound(toscaGetFunction5.getPropertySource()).get().getResponseFormat();
+
+ final var toscaGetFunction6 = new ToscaGetFunctionDataDefinition();
+ toscaGetFunction6.setFunctionType(ToscaGetFunctionType.GET_PROPERTY);
+ toscaGetFunction6.setPropertySource(PropertySource.SELF);
+ toscaGetFunction6.setPropertyPathFromSource(List.of("sourcePath"));
+ toscaGetFunction6.setSourceName("sourceName");
+ toscaGetFunction6.setSourceUniqueId("sourceUniqueId");
+ final ResponseFormat expectedResponse6 = ToscaGetFunctionExceptionSupplier
+ .propertyNameNotFound(toscaGetFunction6.getPropertySource()).get().getResponseFormat();
+
+ final var toscaGetFunction7 = new ToscaGetFunctionDataDefinition();
+ toscaGetFunction7.setFunctionType(ToscaGetFunctionType.GET_PROPERTY);
+ toscaGetFunction7.setPropertySource(PropertySource.SELF);
+ toscaGetFunction7.setPropertyPathFromSource(List.of("sourcePath"));
+ toscaGetFunction7.setSourceName("sourceName");
+ toscaGetFunction7.setSourceUniqueId("sourceUniqueId");
+ toscaGetFunction7.setPropertyName("propertyName");
+ final ResponseFormat expectedResponse7 = ToscaGetFunctionExceptionSupplier
+ .propertyIdNotFound(toscaGetFunction7.getPropertySource()).get().getResponseFormat();
+
+ return Stream.of(
+ Arguments.of(toscaGetFunction1, expectedResponse1),
+ Arguments.of(toscaGetFunction2, expectedResponse2),
+ Arguments.of(toscaGetFunction3, expectedResponse3),
+ Arguments.of(toscaGetFunction4, expectedResponse4),
+ Arguments.of(toscaGetFunction5, expectedResponse5),
+ Arguments.of(toscaGetFunction6, expectedResponse6),
+ Arguments.of(toscaGetFunction7, expectedResponse7)
+ );
+ }
+
}
+