catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ComponentInstanceBusinessLogicTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.components.impl;
  22
  23 import fj.data.Either;
  24 import mockit.Deencapsulation;
  25 import org.apache.commons.lang3.tuple.ImmutablePair;
  26 import org.assertj.core.util.Lists;
  27 import org.junit.Assert;
  28 import org.junit.Before;
  29 import org.junit.Test;
  30 import org.junit.runner.RunWith;
  31 import org.mockito.InjectMocks;
  32 import org.mockito.Mock;
  33 import org.mockito.Mockito;
  34 import org.mockito.MockitoAnnotations;
  35 import org.mockito.junit.MockitoJUnitRunner;
  36 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
  37 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
  38 import org.openecomp.sdc.be.components.validation.UserValidations;
  39 import org.openecomp.sdc.be.config.ConfigurationManager;
  40 import org.openecomp.sdc.be.dao.api.ActionStatus;
  41 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  42 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
  43 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  44 import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
  45 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
  46 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathElementDataDefinition;
  47 import org.openecomp.sdc.be.datatypes.elements.GetPolicyValueDataDefinition;
  48 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  49 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
  50 import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
  51 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  52 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  53 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  54 import org.openecomp.sdc.be.impl.ComponentsUtils;
  55 import org.openecomp.sdc.be.impl.ServletUtils;
  56 import org.openecomp.sdc.be.model.ArtifactDefinition;
  57 import org.openecomp.sdc.be.model.CapabilityDefinition;
  58 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
  59 import org.openecomp.sdc.be.model.Component;
  60 import org.openecomp.sdc.be.model.ComponentInstance;
  61 import org.openecomp.sdc.be.model.ComponentInstanceInput;
  62 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  63 import org.openecomp.sdc.be.model.ComponentParametersView;
  64 import org.openecomp.sdc.be.model.DataTypeDefinition;
  65 import org.openecomp.sdc.be.model.InputDefinition;
  66 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  67 import org.openecomp.sdc.be.model.PolicyDefinition;
  68 import org.openecomp.sdc.be.model.RelationshipImpl;
  69 import org.openecomp.sdc.be.model.RelationshipInfo;
  70 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
  71 import org.openecomp.sdc.be.model.RequirementDefinition;
  72 import org.openecomp.sdc.be.model.Resource;
  73 import org.openecomp.sdc.be.model.Service;
  74 import org.openecomp.sdc.be.model.User;
  75 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
  76 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ForwardingPathOperation;
  77 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  78 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  79 import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation;
  80 import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
  81 import org.openecomp.sdc.be.user.UserBusinessLogic;
  82 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  83 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
  84 import org.openecomp.sdc.common.api.ConfigurationSource;
  85 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  86 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  87 import org.openecomp.sdc.exception.ResponseFormat;
  88
  89 import java.util.ArrayList;
  90 import java.util.Arrays;
  91 import java.util.Collections;
  92 import java.util.HashMap;
  93 import java.util.HashSet;
  94 import java.util.List;
  95 import java.util.Map;
  96 import java.util.Optional;
  97 import java.util.Set;
  98
  99 import static org.assertj.core.api.Assertions.assertThat;
 100 import static org.junit.Assert.assertEquals;
 101 import static org.junit.Assert.assertFalse;
 102 import static org.junit.Assert.assertSame;
 103 import static org.junit.Assert.assertTrue;
 104 import static org.junit.Assert.fail;
 105 import static org.mockito.ArgumentMatchers.any;
 106 import static org.mockito.ArgumentMatchers.anySet;
 107 import static org.mockito.ArgumentMatchers.eq;
 108 import static org.mockito.Mockito.when;
 109
 110 /**
 111  * The test suite designed for test functionality of ComponentInstanceBusinessLogic class
 112  */
 113
 114 @RunWith(MockitoJUnitRunner.class)
 115 public class ComponentInstanceBusinessLogicTest {
 116
 117     private final static String USER_ID = "jh0003";
 118     private final static String COMPONENT_ID = "componentId";
 119     private final static String ORIGIN_COMPONENT_ID = "originComponentId";
 120     private final static String COMPONENT_INST_ID = "componentInstId";
 121     private final static String TO_INSTANCE_ID = "toInstanceId";
 122     private final static String COMPONENT_INSTANCE_ID = "componentInstanceId";
 123     private final static String FROM_INSTANCE_ID = "fromInstanceId";
 124     private final static String RELATION_ID = "relationId";
 125     private final static String CAPABILITY_OWNER_ID = "capabilityOwnerId";
 126     private final static String CAPABILITY_UID = "capabilityUid";
 127     private final static String CAPABILITY_NAME = "capabilityName";
 128     private final static String REQUIREMENT_OWNER_ID = "requirementOwnerId";
 129     private final static String REQUIREMENT_UID = "requirementUid";
 130     private final static String REQUIREMENT_NAME = "requirementName";
 131     private final static String RELATIONSHIP_TYPE = "relationshipType";
 132     private final static String ARTIFACT_1 = "cloudtech_k8s_charts.zip";
 133     private final static String ARTIFACT_2 = "cloudtech_azure_day0.zip";
 134     private final static String ARTIFACT_3 = "cloudtech_aws_configtemplate.zip";
 135     private final static String ARTIFACT_4 = "k8s_charts.zip";
 136     private final static String ARTIFACT_5 = "cloudtech_openstack_configtemplate.zip";
 137     private final static String PROP_NAME = "propName";
 138     private final static String NON_EXIST_NAME = "nonExistName";
 139
 140     static ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(),
 141             "src/test/resources/config/catalog-be");
 142     static ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
 143
 144     @InjectMocks
 145     private static ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
 146     @Mock
 147     ArtifactsBusinessLogic artifactsBusinessLogic;
 148     @Mock
 149     private ComponentsUtils componentsUtils;
 150     @Mock
 151     private ServletUtils servletUtils;
 152     @Mock
 153     private ResponseFormat responseFormat;
 154     @Mock
 155     private ToscaOperationFacade toscaOperationFacade;
 156     @Mock
 157     private UserBusinessLogic userAdmin;
 158     @Mock
 159     private ForwardingPathOperation forwardingPathOperation;
 160     @Mock
 161     private User user;
 162     @Mock
 163     private UserValidations userValidations;
 164     @Mock
 165     GraphLockOperation graphLockOperation;
 166     @Mock
 167     private JanusGraphDao janusGraphDao;
 168     @Mock
 169     ApplicationDataTypeCache dataTypeCache;
 170     @Mock
 171     PropertyOperation propertyOperation;
 172     @Mock
 173     ApplicationDataTypeCache applicationDataTypeCache;
 174
 175     private Component service;
 176     private Component resource;
 177     private ComponentInstance toInstance;
 178     private ComponentInstance fromInstance;
 179     private CapabilityDataDefinition capability;
 180     private RequirementDataDefinition requirement;
 181     private RequirementCapabilityRelDef relation;
 182
 183
 184     @Before
 185     public void init() {
 186         MockitoAnnotations.initMocks(componentInstanceBusinessLogic);
 187         stubMethods();
 188         createComponents();
 189     }
 190
 191     @Test
 192     public void testGetRelationByIdSuccess() {
 193         getServiceRelationByIdSuccess(service);
 194         getServiceRelationByIdSuccess(resource);
 195     }
 196
 197     @Test
 198     public void testGetRelationByIdUserValidationFailure() {
 199         getServiceRelationByIdUserValidationFailure(service);
 200         getServiceRelationByIdUserValidationFailure(resource);
 201     }
 202
 203     @Test
 204     public void testGetRelationByIdComponentNotFoundFailure() {
 205         getRelationByIdComponentNotFoundFailure(service);
 206         getRelationByIdComponentNotFoundFailure(resource);
 207     }
 208
 209     @Test
 210     public void testForwardingPathOnVersionChange() {
 211         getforwardingPathOnVersionChange();
 212     }
 213
 214     @Test
 215     public void testIsCloudSpecificArtifact() {
 216         assertTrue(componentInstanceBusinessLogic.isCloudSpecificArtifact(ARTIFACT_1));
 217         assertTrue(componentInstanceBusinessLogic.isCloudSpecificArtifact(ARTIFACT_2));
 218         assertTrue(componentInstanceBusinessLogic.isCloudSpecificArtifact(ARTIFACT_3));
 219         assertFalse(componentInstanceBusinessLogic.isCloudSpecificArtifact(ARTIFACT_4));
 220         assertFalse(componentInstanceBusinessLogic.isCloudSpecificArtifact(ARTIFACT_5));
 221     }
 222
 223     private void getforwardingPathOnVersionChange(){
 224         String containerComponentParam = "services";
 225         String containerComponentID = "121-cont";
 226         String componentInstanceID = "121-cont-1-comp";
 227         Service component = new Service();
 228         Map<String, ForwardingPathDataDefinition> forwardingPaths = generateForwardingPath(componentInstanceID);
 229
 230         //Add existing componentInstance to component
 231         List<ComponentInstance> componentInstanceList = new ArrayList<>();
 232         ComponentInstance oldComponentInstance = new ComponentInstance();
 233         oldComponentInstance.setName("OLD_COMP_INSTANCE");
 234         oldComponentInstance.setUniqueId(componentInstanceID);
 235         oldComponentInstance.setName(componentInstanceID);
 236         oldComponentInstance.setToscaPresentationValue(JsonPresentationFields.CI_COMPONENT_UID, "1-comp");
 237         componentInstanceList.add(oldComponentInstance);
 238         component.setComponentInstances(componentInstanceList);
 239         component.setForwardingPaths(forwardingPaths);
 240
 241         List<ComponentInstance> componentInstanceListNew = new ArrayList<>();
 242         ComponentInstance newComponentInstance = new ComponentInstance();
 243         String new_Comp_UID = "2-comp";
 244         newComponentInstance.setToscaPresentationValue(JsonPresentationFields.CI_COMPONENT_UID, new_Comp_UID);
 245         newComponentInstance.setUniqueId(new_Comp_UID);
 246         componentInstanceListNew.add(newComponentInstance);
 247         Component component2 = new Service();
 248         component2.setComponentInstances(componentInstanceListNew);
 249
 250         //Mock for getting component
 251         when(toscaOperationFacade.getToscaElement(eq(containerComponentID), any(ComponentParametersView.class)))
 252                 .thenReturn(Either.left(component));
 253         when(toscaOperationFacade.validateComponentExists(any(String.class))).thenReturn(Either.left(Boolean.TRUE));
 254         when(toscaOperationFacade.getToscaFullElement(eq(new_Comp_UID))).thenReturn(Either.left(component2));
 255
 256         Either<Set<String>, ResponseFormat> resultOp = componentInstanceBusinessLogic
 257                                                                .forwardingPathOnVersionChange(containerComponentParam,
 258                                                                        containerComponentID, componentInstanceID,
 259                                                                        newComponentInstance);
 260         assertEquals(1, resultOp.left().value().size());
 261         assertEquals("FP-ID-1", resultOp.left().value().iterator().next());
 262
 263     }
 264
 265     @Test
 266     public void testCreateOrUpdatePropertiesValues2(){
 267         String containerComponentID="containerId";
 268         String resourceInstanceId = "resourceId";
 269         String componentInstanceID = "componentInstance";
 270         List<ComponentInstanceProperty> properties = new ArrayList<>();
 271         ComponentInstanceProperty property = new ComponentInstanceProperty();
 272         property.setName("property");
 273         property.setValue("newVal");
 274         property.setType("string");
 275         properties.add(property);
 276
 277         List<ComponentInstanceProperty> origProperties = new ArrayList<>();
 278         ComponentInstanceProperty origProperty = new ComponentInstanceProperty();
 279         origProperty.setName("property");
 280         origProperty.setValue("value");
 281         origProperty.setType("string");
 282         origProperties.add(origProperty);
 283
 284         Map<String, DataTypeDefinition> types = new HashMap<>();
 285         DataTypeDefinition dataTypeDef = new DataTypeDefinition();
 286         types.put("string", dataTypeDef);
 287
 288         Component component = new Service();
 289         component.setLastUpdaterUserId("userId");
 290         component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 291         Map<String, List<ComponentInstanceProperty>> componentInstanceProps = new HashMap<>();
 292         componentInstanceProps.put("resourceId", origProperties);
 293         component.setComponentInstancesProperties(componentInstanceProps);
 294         ComponentInstance ci = createComponentInstance("ci1");
 295         ci.setUniqueId("resourceId");
 296         component.setComponentInstances(Arrays.asList(ci, createComponentInstance("ci2"),
 297                 createComponentInstance(componentInstanceID)));
 298         HashMap<String, DataTypeDefinition> dataTypeDefinitionHashMap = new HashMap<>();
 299         DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
 300         dataTypeDefinition.setName("string");
 301         dataTypeDefinitionHashMap.put("string", dataTypeDefinition);
 302
 303         //when(userValidations.validateUserExists(user.getUserId(), false)).thenReturn(user);
 304         when(toscaOperationFacade.getToscaElement(containerComponentID, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(component));
 305         when(graphLockOperation.lockComponent(containerComponentID, NodeTypeEnum.ResourceInstance)).thenReturn(StorageOperationStatus.OK);
 306         when(dataTypeCache.getAll()).thenReturn(Either.left(types));
 307         when(propertyOperation.validateAndUpdatePropertyValue(property.getType(), "newVal", true, null, types))
 308                 .thenReturn(Either.left("newVal"));
 309         when(propertyOperation.validateAndUpdateRules("string", property.getRules(),
 310                 null, types, true)).thenReturn(ImmutablePair.of("string", null));
 311         when(toscaOperationFacade.updateComponentInstanceProperty(component, ci.getUniqueId(),
 312                 origProperty)).thenReturn(StorageOperationStatus.OK);
 313         origProperties.get(0).setValue("newVal");
 314         when(toscaOperationFacade.updateComponentInstanceMetadataOfTopologyTemplate(component)).thenReturn(Either.left(component));
 315         when (janusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
 316         when(graphLockOperation.unlockComponent(containerComponentID, NodeTypeEnum.ResourceInstance)).thenReturn(StorageOperationStatus.OK);
 317
 318         Either<List<ComponentInstanceProperty>, ResponseFormat> responseFormatEither = componentInstanceBusinessLogic.createOrUpdatePropertiesValues(
 319                 ComponentTypeEnum.RESOURCE_INSTANCE, containerComponentID, resourceInstanceId, properties, "userId");
 320         assertThat(responseFormatEither.left().value()).isEqualTo(properties);
 321     }
 322
 323     @Test
 324     public void testCreateOrUpdatePropertiesValuesPropertyNotExists(){
 325         String containerComponentID="containerId";
 326         String resourceInstanceId = "resourceId";
 327         String componentInstanceID = "componentInstance";
 328         List<ComponentInstanceProperty> properties = new ArrayList<>();
 329         ComponentInstanceProperty property = new ComponentInstanceProperty();
 330         property.setName("property");
 331         property.setValue("newVal");
 332         property.setType("string");
 333         properties.add(property);
 334
 335         List<ComponentInstanceProperty> origProperties = new ArrayList<>();
 336
 337         Map<String, DataTypeDefinition> types = new HashMap<>();
 338         DataTypeDefinition dataTypeDef = new DataTypeDefinition();
 339         types.put("string", dataTypeDef);
 340
 341         Component component = new Service();
 342         component.setLastUpdaterUserId("userId");
 343         component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 344         Map<String, List<ComponentInstanceProperty>> componentInstanceProps = new HashMap<>();
 345         componentInstanceProps.put("resourceId", origProperties);
 346         component.setComponentInstancesProperties(componentInstanceProps);
 347         ComponentInstance ci = createComponentInstance("ci1");
 348         ci.setUniqueId("resourceId");
 349         component.setComponentInstances(Arrays.asList(ci, createComponentInstance("ci2"),
 350                 createComponentInstance(componentInstanceID)));
 351         HashMap<String, DataTypeDefinition> dataTypeDefinitionHashMap = new HashMap<>();
 352         DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
 353         dataTypeDefinition.setName("string");
 354         dataTypeDefinitionHashMap.put("string", dataTypeDefinition);
 355
 356         //when(userValidations.validateUserExists(user.getUserId(), false)).thenReturn(user);
 357         when(toscaOperationFacade.getToscaElement(containerComponentID, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(component));
 358         when(graphLockOperation.lockComponent(containerComponentID, NodeTypeEnum.ResourceInstance)).thenReturn(StorageOperationStatus.OK);
 359         //when(dataTypeCache.getAll()).thenReturn(Either.left(types));
 360         //when (janusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
 361         when(graphLockOperation.unlockComponent(containerComponentID, NodeTypeEnum.ResourceInstance)).thenReturn(StorageOperationStatus.OK);
 362
 363         try {
 364             componentInstanceBusinessLogic.createOrUpdatePropertiesValues(
 365                     ComponentTypeEnum.RESOURCE_INSTANCE, containerComponentID, resourceInstanceId, properties, "userId");
 366         } catch (ComponentException e) {
 367             assertThat(e.getActionStatus()).isEqualTo(ActionStatus.PROPERTY_NOT_FOUND);
 368         }
 369
 370     }
 371
 372
 373     @Test
 374     public void testCreateOrUpdatePropertiesValuesValidationFailure(){
 375         String containerComponentID="containerId";
 376         String resourceInstanceId = "resourceId";
 377         String componentInstanceID = "componentInstance";
 378         List<ComponentInstanceProperty> properties = new ArrayList<>();
 379         ComponentInstanceProperty property = new ComponentInstanceProperty();
 380         property.setName("property");
 381         property.setValue("newVal");
 382         property.setType("string");
 383         properties.add(property);
 384
 385         List<ComponentInstanceProperty> origProperties = new ArrayList<>();
 386         ComponentInstanceProperty origProperty = new ComponentInstanceProperty();
 387         origProperty.setName("property");
 388         origProperty.setValue("value");
 389         origProperty.setType("string");
 390         origProperties.add(origProperty);
 391
 392         Map<String, DataTypeDefinition> types = new HashMap<>();
 393         DataTypeDefinition dataTypeDef = new DataTypeDefinition();
 394         types.put("string", dataTypeDef);
 395
 396         Component component = new Service();
 397         component.setLastUpdaterUserId("userId");
 398         component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 399         Map<String, List<ComponentInstanceProperty>> componentInstanceProps = new HashMap<>();
 400         componentInstanceProps.put("resourceId", origProperties);
 401         component.setComponentInstancesProperties(componentInstanceProps);
 402         ComponentInstance ci = createComponentInstance("ci1");
 403         ci.setUniqueId("resourceId");
 404         component.setComponentInstances(Arrays.asList(ci, createComponentInstance("ci2"),
 405                 createComponentInstance(componentInstanceID)));
 406         HashMap<String, DataTypeDefinition> dataTypeDefinitionHashMap = new HashMap<>();
 407         DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
 408         dataTypeDefinition.setName("string");
 409         dataTypeDefinitionHashMap.put("string", dataTypeDefinition);
 410
 411         //when(userValidations.validateUserExists(user.getUserId(), false)).thenReturn(user);
 412         when(toscaOperationFacade.getToscaElement(containerComponentID, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(component));
 413         when(graphLockOperation.lockComponent(containerComponentID, NodeTypeEnum.ResourceInstance)).thenReturn(StorageOperationStatus.OK);
 414         when(dataTypeCache.getAll()).thenReturn(Either.left(types));
 415         when(propertyOperation.validateAndUpdatePropertyValue(property.getType(), "newVal", true, null, types))
 416                 .thenReturn(Either.right(false));
 417         when(componentsUtils.convertFromStorageResponse(StorageOperationStatus.BAD_REQUEST)).thenReturn(ActionStatus.INVALID_CONTENT);
 418
 419         try{
 420             componentInstanceBusinessLogic.createOrUpdatePropertiesValues(
 421                     ComponentTypeEnum.RESOURCE_INSTANCE, containerComponentID, resourceInstanceId, properties, "userId");
 422         } catch(ComponentException e){
 423             assertThat(e.getActionStatus()).isEqualTo(ActionStatus.INVALID_CONTENT);
 424             return;
 425         }
 426         fail();
 427     }
 428
 429     @Test
 430     public void testCreateOrUpdatePropertiesValuesMissingFieldFailure(){
 431         String containerComponentID="containerId";
 432         String resourceInstanceId = "resourceId";
 433         String componentInstanceID = "componentInstance";
 434         List<ComponentInstanceProperty> properties = new ArrayList<>();
 435         ComponentInstanceProperty property = new ComponentInstanceProperty();
 436         property.setValue("newVal");
 437         property.setType("string");
 438         properties.add(property);
 439
 440         List<ComponentInstanceProperty> origProperties = new ArrayList<>();
 441         ComponentInstanceProperty origProperty = new ComponentInstanceProperty();
 442         origProperty.setName("property");
 443         origProperty.setValue("value");
 444         origProperty.setType("string");
 445         origProperties.add(origProperty);
 446
 447         Component component = new Service();
 448         component.setLastUpdaterUserId("userId");
 449         component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 450         Map<String, List<ComponentInstanceProperty>> componentInstanceProps = new HashMap<>();
 451         componentInstanceProps.put("resourceId", origProperties);
 452         component.setComponentInstancesProperties(componentInstanceProps);
 453         ComponentInstance ci = createComponentInstance("ci1");
 454         ci.setUniqueId("resourceId");
 455         component.setComponentInstances(Arrays.asList(ci, createComponentInstance("ci2"),
 456                 createComponentInstance(componentInstanceID)));
 457
 458         HashMap<String, DataTypeDefinition> dataTypeDefinitionHashMap = new HashMap<>();
 459         DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
 460         dataTypeDefinition.setName("string");
 461         dataTypeDefinitionHashMap.put("string", dataTypeDefinition);
 462
 463         //when(userValidations.validateUserExists(user.getUserId(), false)).thenReturn(user);
 464         when(toscaOperationFacade.getToscaElement(containerComponentID, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(component));
 465         when(graphLockOperation.lockComponent(containerComponentID, NodeTypeEnum.ResourceInstance)).thenReturn(StorageOperationStatus.OK);
 466
 467         try{
 468             componentInstanceBusinessLogic.createOrUpdatePropertiesValues(
 469                     ComponentTypeEnum.RESOURCE_INSTANCE, containerComponentID, resourceInstanceId, properties, "userId");
 470         } catch(ComponentException e){
 471             assertThat(e.getActionStatus()).isEqualTo(ActionStatus.MISSING_PROPERTY_NAME);
 472         }
 473     }
 474
 475     @Test
 476     public void testDeleteForwardingPathsWhenComponentinstanceDeleted() {
 477
 478         ComponentTypeEnum containerComponentType = ComponentTypeEnum.findByParamName("services");
 479         String containerComponentID = "Service-comp";
 480         String componentInstanceID = "NodeA1";
 481         Service component = new Service();
 482         component.setComponentInstances(Arrays.asList(createComponentInstance("NodeA2"), createComponentInstance("NodeB2"),
 483             createComponentInstance(componentInstanceID)));
 484
 485         component.addForwardingPath(createPath("path1", componentInstanceID, "NodeB1", "1"));
 486         component.addForwardingPath(createPath("Path2", "NodeA2", "NodeB2", "2"));
 487         when(toscaOperationFacade.getToscaElement(eq(containerComponentID), any(ComponentParametersView.class)))
 488                 .thenReturn(Either.left(component));
 489         when(toscaOperationFacade.getToscaElement(eq(containerComponentID))).thenReturn(Either.left(component));
 490         when(forwardingPathOperation.deleteForwardingPath(any(Service.class), anySet()))
 491                 .thenReturn(Either.left(new HashSet<>()));
 492         final ComponentInstance ci = new ComponentInstance();
 493         ci.setName(componentInstanceID);
 494         ComponentInstance responseFormatEither = componentInstanceBusinessLogic.deleteForwardingPathsRelatedTobeDeletedComponentInstance(
 495             containerComponentID, containerComponentType, ci);
 496         assertThat(!responseFormatEither.isEmpty()).isEqualTo(true);
 497
 498     }
 499
 500     @Test
 501     public void testAddComponentInstanceDeploymentArtifacts() {
 502
 503         Component containerComponent = new Service();
 504         ComponentInstance componentInstance = new ComponentInstance();
 505         componentInstance.setUniqueId(COMPONENT_INSTANCE_ID);
 506         Component originComponent = fillOriginComponent(new Resource());
 507
 508         Map<String, ArtifactDefinition> artifacts = new HashMap<>();
 509         ArtifactDefinition deploymentArtifact1 = getArtifact("deploymentArtifact1", ArtifactTypeEnum.HEAT.getType());
 510         artifacts.put(deploymentArtifact1.getArtifactLabel(), deploymentArtifact1);
 511         ArtifactDefinition deploymentArtifact2 = getArtifact("deploymentArtifact2", ArtifactTypeEnum.HEAT_ENV.getType());
 512         artifacts.put(deploymentArtifact2.getArtifactLabel(), deploymentArtifact2);
 513         ArtifactDefinition deploymentArtifact3 = getArtifact("deploymentArtifact3", ArtifactTypeEnum.HEAT_VOL.getType());
 514         artifacts.put(deploymentArtifact3.getArtifactLabel(), deploymentArtifact3);
 515         ArtifactDefinition heatEnvPlaceHolder = getArtifact("deploymentArtifact4", ArtifactTypeEnum.HEAT_ENV.getType());
 516         ArtifactDefinition heatEnvPlaceHolder2 = getArtifact("deploymentArtifact5", ArtifactTypeEnum.HEAT_ENV.getType());
 517
 518         Either<Map<String, ArtifactDefinition>, StorageOperationStatus> getResourceDeploymentArtifacts = Either.left(artifacts);
 519
 520         Map<String, ArtifactDefinition> finalDeploymentArtifacts = new HashMap<>();
 521         finalDeploymentArtifacts.put(deploymentArtifact1.getArtifactLabel(), deploymentArtifact1);
 522         finalDeploymentArtifacts.put(deploymentArtifact3.getArtifactLabel(), deploymentArtifact3);
 523         finalDeploymentArtifacts.put(heatEnvPlaceHolder.getArtifactLabel(), heatEnvPlaceHolder);
 524         finalDeploymentArtifacts.put(heatEnvPlaceHolder2.getArtifactLabel(), heatEnvPlaceHolder2);
 525
 526
 527         when(artifactsBusinessLogic.getArtifacts(componentInstance.getComponentUid(), NodeTypeEnum.Resource,
 528                 ArtifactGroupTypeEnum.DEPLOYMENT, null)).thenReturn(getResourceDeploymentArtifacts);
 529         when(artifactsBusinessLogic.createHeatEnvPlaceHolder(new ArrayList<>(),
 530                 deploymentArtifact1, ArtifactsBusinessLogic.HEAT_ENV_NAME, componentInstance.getUniqueId(),
 531                 NodeTypeEnum.ResourceInstance, componentInstance.getName(), user, containerComponent,
 532                 null)).thenReturn(heatEnvPlaceHolder);
 533         when(artifactsBusinessLogic.createHeatEnvPlaceHolder(new ArrayList<>(),
 534                 deploymentArtifact3, ArtifactsBusinessLogic.HEAT_ENV_NAME, componentInstance.getUniqueId(),
 535                 NodeTypeEnum.ResourceInstance, componentInstance.getName(), user, containerComponent,
 536                 null)).thenReturn(heatEnvPlaceHolder2);
 537
 538
 539         when(toscaOperationFacade.addDeploymentArtifactsToInstance(containerComponent.getUniqueId(), componentInstance, finalDeploymentArtifacts)).thenReturn(StorageOperationStatus.OK);
 540         when(toscaOperationFacade.addGroupInstancesToComponentInstance(containerComponent, componentInstance, null, new HashMap<>())).thenReturn(StorageOperationStatus.OK);
 541         when(toscaOperationFacade.addInformationalArtifactsToInstance(containerComponent.getUniqueId(), componentInstance, null)).thenReturn(StorageOperationStatus.OK);
 542
 543
 544         ActionStatus status = componentInstanceBusinessLogic.addComponentInstanceArtifacts(containerComponent,
 545                 componentInstance, originComponent, user, null);
 546
 547         assertThat(status).isEqualTo(ActionStatus.OK);
 548
 549     }
 550
 551     private Component fillOriginComponent(Resource originComponent) {
 552         originComponent.setUniqueId("resourceId");
 553         originComponent.setUniqueId(ORIGIN_COMPONENT_ID);
 554         originComponent.setComponentInstances(Lists.newArrayList(toInstance,fromInstance));
 555         originComponent.setComponentType(ComponentTypeEnum.RESOURCE);
 556         originComponent.setState(LifecycleStateEnum.CERTIFIED);
 557         return originComponent;
 558     }
 559
 560     private ArtifactDefinition getArtifact(String artifactLabel, String artifactType) {
 561         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
 562         artifactDefinition.setArtifactLabel(artifactLabel);
 563         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 564         artifactDefinition.setEsId("esId" + artifactLabel);
 565         artifactDefinition.setArtifactType(artifactType);
 566         return artifactDefinition;
 567     }
 568
 569     private ComponentInstance createComponentInstance(String path1) {
 570         ComponentInstance componentInstance = new ComponentInstance();
 571         componentInstance.setName(path1);
 572         return componentInstance;
 573     }
 574
 575     private ForwardingPathDataDefinition createPath(String pathName, String fromNode, String toNode, String uniqueId) {
 576         ForwardingPathDataDefinition forwardingPath = new ForwardingPathDataDefinition(pathName);
 577         forwardingPath.setProtocol("protocol");
 578         forwardingPath.setDestinationPortNumber("port");
 579         forwardingPath.setUniqueId(uniqueId);
 580         ListDataDefinition<ForwardingPathElementDataDefinition> forwardingPathElementListDataDefinition =
 581                 new ListDataDefinition<>();
 582         forwardingPathElementListDataDefinition
 583                 .add(new ForwardingPathElementDataDefinition(fromNode, toNode, "nodeAcpType", "nodeBcpType",
 584                         "nodeDcpName", "nodeBcpName"));
 585         forwardingPath.setPathElements(forwardingPathElementListDataDefinition);
 586
 587         return forwardingPath;
 588     }
 589
 590
 591     private Map<String, ForwardingPathDataDefinition> generateForwardingPath(String componentInstanceID) {
 592         ForwardingPathDataDefinition forwardingPath = new ForwardingPathDataDefinition("fpName");
 593         String protocol = "protocol";
 594         forwardingPath.setProtocol(protocol);
 595         forwardingPath.setDestinationPortNumber("DestinationPortNumber");
 596         forwardingPath.setUniqueId("FP-ID-1");
 597         ListDataDefinition<ForwardingPathElementDataDefinition> forwardingPathElementListDataDefinition =
 598             new ListDataDefinition<>();
 599         forwardingPathElementListDataDefinition
 600                 .add(new ForwardingPathElementDataDefinition(componentInstanceID, "nodeB", "nodeA_FORWARDER_CAPABILITY",
 601                         "nodeBcpType", "nodeDcpName", "nodeBcpName"));
 602         forwardingPath.setPathElements(forwardingPathElementListDataDefinition);
 603         Map<String, ForwardingPathDataDefinition> forwardingPaths = new HashMap<>();
 604         forwardingPaths.put("1122", forwardingPath);
 605         return forwardingPaths;
 606     }
 607
 608   @SuppressWarnings("unchecked")
 609     private void getServiceRelationByIdSuccess(Component component){
 610         Either<Component, StorageOperationStatus> getComponentRes = Either.left(component);
 611         when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class)))
 612                 .thenReturn(getComponentRes);
 613         Either<RequirementCapabilityRelDef, ResponseFormat> response = componentInstanceBusinessLogic
 614                                                                                .getRelationById(COMPONENT_ID,
 615                                                                                        RELATION_ID, USER_ID,
 616                                                                                        component.getComponentType());
 617         assertTrue(response.isLeft());
 618     }
 619
 620     private void getServiceRelationByIdUserValidationFailure(Component component) {
 621         when(userValidations.validateUserExists(eq(USER_ID))).thenThrow(new ByActionStatusComponentException(ActionStatus.USER_NOT_FOUND));
 622         try {
 623             componentInstanceBusinessLogic
 624                     .getRelationById(COMPONENT_ID, RELATION_ID, USER_ID, component.getComponentType());
 625         } catch (ByActionStatusComponentException e) {
 626             assertSame(e.getActionStatus(), ActionStatus.USER_NOT_FOUND);
 627         }
 628     }
 629
 630     private void getRelationByIdComponentNotFoundFailure(Component component) {
 631         Either<User, ActionStatus> eitherCreator = Either.left(user);
 632         Either<Component, StorageOperationStatus> getComponentRes = Either.right(StorageOperationStatus.NOT_FOUND);
 633         when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class)))
 634                 .thenReturn(getComponentRes);
 635
 636         Either<RequirementCapabilityRelDef, ResponseFormat> response = componentInstanceBusinessLogic
 637                                                                                .getRelationById(COMPONENT_ID,
 638                                                                                        RELATION_ID, USER_ID,
 639                                                                                        component.getComponentType());
 640         assertTrue(response.isRight());
 641     }
 642
 643     private void stubMethods() {
 644         when(userValidations.validateUserExists(eq(USER_ID))).thenReturn(user);
 645         when(componentsUtils.convertFromStorageResponse(eq(StorageOperationStatus.GENERAL_ERROR),any(ComponentTypeEnum.class)))
 646                 .thenReturn(ActionStatus.GENERAL_ERROR);
 647     }
 648
 649     private void createComponents() {
 650         createRelation();
 651         createInstances();
 652         createService();
 653         createResource();
 654     }
 655
 656     private void createResource() {
 657         resource = new Resource();
 658         resource.setUniqueId(COMPONENT_ID);
 659         resource.setComponentInstancesRelations(Lists.newArrayList(relation));
 660         resource.setComponentInstances(Lists.newArrayList(toInstance, fromInstance));
 661         resource.setCapabilities(toInstance.getCapabilities());
 662         resource.setRequirements(fromInstance.getRequirements());
 663         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 664         resource.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 665     }
 666
 667
 668     private void createService() {
 669         service = new Service();
 670         service.setUniqueId(COMPONENT_ID);
 671         service.setComponentInstancesRelations(Lists.newArrayList(relation));
 672         service.setComponentInstances(Lists.newArrayList(toInstance, fromInstance));
 673         service.setCapabilities(toInstance.getCapabilities());
 674         service.setRequirements(fromInstance.getRequirements());
 675         service.setComponentType(ComponentTypeEnum.SERVICE);
 676         service.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 677     }
 678
 679
 680     private void createInstances() {
 681         toInstance = new ComponentInstance();
 682         toInstance.setUniqueId(TO_INSTANCE_ID);
 683
 684         fromInstance = new ComponentInstance();
 685         fromInstance.setUniqueId(FROM_INSTANCE_ID);
 686
 687         capability = new CapabilityDataDefinition();
 688         capability.setOwnerId(CAPABILITY_OWNER_ID);
 689         capability.setUniqueId(CAPABILITY_UID);
 690         capability.setName(CAPABILITY_NAME);
 691
 692         Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
 693         capabilities.put(capability.getName(), Lists.newArrayList(new CapabilityDefinition(capability)));
 694
 695         requirement = new RequirementDataDefinition();
 696         requirement.setOwnerId(REQUIREMENT_OWNER_ID);
 697         requirement.setUniqueId(REQUIREMENT_UID);
 698         requirement.setName(REQUIREMENT_NAME);
 699         requirement.setRelationship(RELATIONSHIP_TYPE);
 700
 701
 702         Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
 703         requirements.put(requirement.getCapability(), Lists.newArrayList(new RequirementDefinition(requirement)));
 704
 705         toInstance.setCapabilities(capabilities);
 706         fromInstance.setRequirements(requirements);
 707     }
 708
 709
 710     private void createRelation() {
 711
 712         relation = new RequirementCapabilityRelDef();
 713         CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
 714         RelationshipInfo relationInfo = new RelationshipInfo();
 715         relationInfo.setId(RELATION_ID);
 716         relationship.setRelation(relationInfo);
 717
 718         relation.setRelationships(Lists.newArrayList(relationship));
 719         relation.setToNode(TO_INSTANCE_ID);
 720         relation.setFromNode(FROM_INSTANCE_ID);
 721
 722         relationInfo.setCapabilityOwnerId(CAPABILITY_OWNER_ID);
 723         relationInfo.setCapabilityUid(CAPABILITY_UID);
 724         relationInfo.setCapability(CAPABILITY_NAME);
 725         relationInfo.setRequirementOwnerId(REQUIREMENT_OWNER_ID);
 726         relationInfo.setRequirementUid(REQUIREMENT_UID);
 727         relationInfo.setRequirement(REQUIREMENT_NAME);
 728         RelationshipImpl relationshipImpl = new RelationshipImpl();
 729         relationshipImpl.setType(RELATIONSHIP_TYPE);
 730         relationInfo.setRelationships(relationshipImpl);
 731     }
 732
 733     private ComponentInstanceBusinessLogic createTestSubject() {
 734         return componentInstanceBusinessLogic;
 735     }
 736
 737
 738     @Test
 739     public void testChangeServiceProxyVersion() {
 740         ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
 741
 742         Either<ComponentInstance, ResponseFormat> result;
 743
 744         // default test
 745         componentInstanceBusinessLogic = createTestSubject();
 746         result = componentInstanceBusinessLogic.changeServiceProxyVersion();
 747     }
 748
 749
 750     @Test
 751     public void testCreateServiceProxy() {
 752         ComponentInstanceBusinessLogic testSubject;
 753         Either<ComponentInstance, ResponseFormat> result;
 754
 755         // default test
 756         testSubject = createTestSubject();
 757         result = testSubject.createServiceProxy();
 758     }
 759
 760
 761
 762
 763
 764     @Test
 765     public void testDeleteServiceProxy() {
 766         ComponentInstanceBusinessLogic testSubject;
 767
 768         Either<ComponentInstance, ResponseFormat> result;
 769
 770         // default test
 771         testSubject = createTestSubject();
 772         result = testSubject.deleteServiceProxy();
 773     }
 774
 775
 776     @Test
 777     public void testGetComponentInstanceInputsByInputId() {
 778         ComponentInstanceBusinessLogic testSubject;
 779         Component component = new Service();
 780         String inputId = "";
 781         List<ComponentInstanceInput> result;
 782
 783         // default test
 784         testSubject = createTestSubject();
 785         result = testSubject.getComponentInstanceInputsByInputId(component, inputId);
 786     }
 787
 788
 789     @Test
 790     public void testGetComponentInstancePropertiesByInputId() {
 791         ComponentInstanceBusinessLogic testSubject;
 792         Component component = new Service();
 793         String inputId = "";
 794         List<ComponentInstanceProperty> result;
 795
 796         // default test
 797         testSubject = createTestSubject();
 798         result = testSubject.getComponentInstancePropertiesByInputId(component, inputId);
 799     }
 800
 801
 802     @Test
 803     public void testGetRelationById() {
 804         ComponentInstanceBusinessLogic testSubject;
 805         String componentId = "";
 806         String relationId = "";
 807         String userId = user.getUserId();
 808         ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE_INSTANCE;
 809         Either<RequirementCapabilityRelDef, ResponseFormat> result;
 810
 811         // default test
 812         testSubject = createTestSubject();
 813         result = testSubject.getRelationById(componentId, relationId, userId, componentTypeEnum);
 814     }
 815
 816      @Test
 817     public void testValidateParent()  {
 818         ComponentInstanceBusinessLogic testSubject;
 819         createResource();
 820         String nodeTemplateId = "";
 821         boolean result;
 822
 823         // default test
 824         testSubject = createTestSubject();
 825         result = Deencapsulation.invoke(testSubject, "validateParent", new Object[] {resource, nodeTemplateId});
 826     }
 827
 828
 829     @Test
 830     public void testGetComponentType() {
 831         ComponentInstanceBusinessLogic testSubject;
 832         ComponentTypeEnum result;
 833
 834         // default test
 835         testSubject = createTestSubject();
 836         result = Deencapsulation.invoke(testSubject, "getComponentType", new Object[] {ComponentTypeEnum.class});
 837     }
 838
 839
 840     @Test
 841     public void testGetNewGroupName() {
 842         ComponentInstanceBusinessLogic testSubject;
 843         String oldPrefix = "";
 844         String newNormailzedPrefix = "";
 845         String qualifiedGroupInstanceName = "";
 846         String result;
 847
 848         // test 1
 849         testSubject = createTestSubject();
 850         result = Deencapsulation.invoke(testSubject, "getNewGroupName",
 851                 new Object[] {oldPrefix, newNormailzedPrefix, qualifiedGroupInstanceName});
 852     }
 853
 854
 855     @Test
 856     public void testUpdateComponentInstanceMetadata_3() {
 857         ComponentInstanceBusinessLogic testSubject;
 858         createInstances();
 859         ComponentInstance newComponentInstance = null;
 860         ComponentInstance result;
 861
 862         // default test
 863         testSubject = createTestSubject();
 864         result = Deencapsulation
 865                          .invoke(testSubject, "updateComponentInstanceMetadata", new Object[] {toInstance, toInstance});
 866     }
 867
 868     @Test
 869     public void testFindRelation() throws Exception {
 870         ComponentInstanceBusinessLogic testSubject;
 871         String relationId = "";
 872         List<RequirementCapabilityRelDef> requirementCapabilityRelations = new ArrayList<>();
 873         RequirementCapabilityRelDef result;
 874
 875         // default test
 876         testSubject = createTestSubject();
 877         result = Deencapsulation.invoke(testSubject, "findRelation",
 878                 new Object[] {relationId, requirementCapabilityRelations});
 879     }
 880
 881
 882     @Test
 883     public void testCreateOrUpdatePropertiesValues() throws Exception {
 884         ComponentInstanceBusinessLogic testSubject;
 885         ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
 886         createResource();
 887         String componentId = resource.getUniqueId();
 888         String resourceInstanceId = "";
 889         List<ComponentInstanceProperty> properties = new ArrayList<>();
 890         String userId = user.getUserId();
 891         Either<List<ComponentInstanceProperty>, ResponseFormat> result;
 892
 893
 894         when(toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll))
 895                 .thenReturn(Either.left(resource));
 896
 897         // test 1
 898         testSubject = createTestSubject();
 899         result = testSubject
 900                          .createOrUpdatePropertiesValues(componentTypeEnum, componentId, resourceInstanceId, properties,
 901                                  userId);
 902
 903         componentTypeEnum = null;
 904         result = testSubject
 905                          .createOrUpdatePropertiesValues(componentTypeEnum, componentId, resourceInstanceId, properties,
 906                                  userId);
 907
 908         //        when(toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll)).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 909         result = testSubject
 910                          .createOrUpdatePropertiesValues(componentTypeEnum, componentId, resourceInstanceId, properties,
 911                                  userId);
 912
 913     }
 914
 915
 916     @Test
 917     public void testUpdateCapabilityPropertyOnContainerComponent() throws Exception {
 918         ComponentInstanceBusinessLogic testSubject;
 919         ComponentInstanceProperty property = new ComponentInstanceProperty();
 920         String newValue = "";
 921         createResource();
 922         createInstances();
 923         String capabilityType = "";
 924         String capabilityName = "";
 925         ResponseFormat result;
 926
 927         // default test
 928         testSubject = createTestSubject();
 929         result = Deencapsulation.invoke(testSubject, "updateCapabilityPropertyOnContainerComponent",
 930                 new Object[] {property, newValue, resource, toInstance, capabilityType, capabilityName});
 931     }
 932
 933
 934     @Test
 935     public void testCreateOrUpdateInstanceInputValues() throws Exception {
 936         ComponentInstanceBusinessLogic testSubject;
 937         ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
 938         createResource();
 939         String componentId = resource.getUniqueId();
 940         String resourceInstanceId = "";
 941         List<ComponentInstanceInput> inputs = new ArrayList<>();
 942         String userId = user.getUserId();
 943         Either<List<ComponentInstanceInput>, ResponseFormat> result;
 944
 945         when(toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll))
 946                 .thenReturn(Either.left(resource));
 947
 948         // test 1
 949         testSubject = createTestSubject();
 950         result = testSubject
 951                          .createOrUpdateInstanceInputValues(componentTypeEnum, componentId, resourceInstanceId, inputs,
 952                                  userId);
 953         componentTypeEnum = null;
 954         result = testSubject
 955                          .createOrUpdateInstanceInputValues(componentTypeEnum, componentId, resourceInstanceId, inputs,
 956                                  userId);
 957
 958
 959         //        when(toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll)).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 960         result = testSubject
 961                          .createOrUpdateInstanceInputValues(componentTypeEnum, componentId, resourceInstanceId, inputs,
 962                                  userId);
 963
 964     }
 965
 966
 967     @Test
 968     public void testCreateOrUpdateGroupInstancePropertyValue() throws Exception {
 969         ComponentInstanceBusinessLogic testSubject;
 970         ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
 971         createResource();
 972         String componentId = resource.getUniqueId();
 973         String resourceInstanceId = "";
 974         String groupInstanceId = "";
 975         ComponentInstanceProperty property = new ComponentInstanceProperty();
 976         String userId = user.getUserId();
 977         Either<ComponentInstanceProperty, ResponseFormat> result;
 978
 979
 980         when(toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseMetadata))
 981                 .thenReturn(Either.left(resource));
 982
 983         // test 1
 984         testSubject = createTestSubject();
 985         result = testSubject
 986                          .createOrUpdateGroupInstancePropertyValue(componentTypeEnum, componentId, resourceInstanceId,
 987                                  groupInstanceId, property, userId);
 988         componentTypeEnum = null;
 989         result = testSubject
 990                          .createOrUpdateGroupInstancePropertyValue(componentTypeEnum, componentId, resourceInstanceId,
 991                                  groupInstanceId, property, userId);
 992
 993         //        when(toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 994         result = testSubject
 995                          .createOrUpdateGroupInstancePropertyValue(componentTypeEnum, componentId, resourceInstanceId,
 996                                  groupInstanceId, property, userId);
 997     }
 998
 999
1000     @Test
1001     public void testDeletePropertyValue() throws Exception {
1002         ComponentInstanceBusinessLogic testSubject;
1003         ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
1004         createService();
1005         String serviceId = service.getUniqueId();
1006         String resourceInstanceId = "";
1007         String propertyValueId = "";
1008         String userId = user.getUserId();
1009         Either<ComponentInstanceProperty, ResponseFormat> result;
1010
1011         when(toscaOperationFacade.getToscaElement(serviceId, JsonParseFlagEnum.ParseMetadata))
1012                 .thenReturn(Either.left(service));
1013
1014         // test 1
1015         testSubject = createTestSubject();
1016         result = testSubject.deletePropertyValue(componentTypeEnum, serviceId, resourceInstanceId, propertyValueId,
1017                 userId);
1018         componentTypeEnum = null;
1019         result = testSubject.deletePropertyValue(componentTypeEnum, serviceId, resourceInstanceId, propertyValueId,
1020                 userId);
1021
1022         //        when(toscaOperationFacade.getToscaElement(serviceId, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1023         result = testSubject.deletePropertyValue(componentTypeEnum, serviceId, resourceInstanceId, propertyValueId,
1024                 userId);
1025     }
1026
1027     @Test
1028     public void testGetComponentParametersViewForForwardingPath() throws Exception {
1029         ComponentInstanceBusinessLogic testSubject;
1030         ComponentParametersView result;
1031
1032         // default test
1033         testSubject = createTestSubject();
1034         result = Deencapsulation.invoke(testSubject, "getComponentParametersViewForForwardingPath");
1035     }
1036
1037     @Test
1038     public void testGetResourceInstanceById() throws Exception {
1039         ComponentInstanceBusinessLogic testSubject;
1040         createResource();
1041         String instanceId = "";
1042         Either<ComponentInstance, StorageOperationStatus> result;
1043
1044         // default test
1045         testSubject = createTestSubject();
1046         result = Deencapsulation.invoke(testSubject, "getResourceInstanceById", new Object[] {resource, instanceId});
1047     }
1048
1049     @Test
1050     public void testUpdateInstanceCapabilityProperties_1() throws Exception {
1051         ComponentInstanceBusinessLogic testSubject;
1052         ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
1053         createResource();
1054         String containerComponentId = resource.getUniqueId();
1055         String componentInstanceUniqueId = "";
1056         String capabilityType = "";
1057         String capabilityName = "";
1058         List<ComponentInstanceProperty> properties = new ArrayList<>();
1059         String userId = user.getUserId();
1060         Either<List<ComponentInstanceProperty>, ResponseFormat> result;
1061
1062
1063         when(toscaOperationFacade.getToscaFullElement(containerComponentId))
1064                 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1065         // test 1
1066         testSubject = createTestSubject();
1067         result = testSubject.updateInstanceCapabilityProperties(componentTypeEnum, containerComponentId,
1068                 componentInstanceUniqueId, capabilityType, capabilityName, properties, userId);
1069         when(toscaOperationFacade.getToscaFullElement(containerComponentId)).thenReturn(Either.left(resource));
1070         result = testSubject.updateInstanceCapabilityProperties(componentTypeEnum, containerComponentId,
1071                 componentInstanceUniqueId, capabilityType, capabilityName, properties, userId);
1072     }
1073
1074     @Test
1075     public void testCopyComponentInstanceWrongUserId() {
1076
1077         Either<Map<String, ComponentInstance>, ResponseFormat> result;
1078         ComponentInstance inputComponentInstance = createComponetInstanceFromComponent(resource);
1079         String containerComponentId = service.getUniqueId();
1080         String componentInstanceId = resource.getUniqueId();
1081         String oldLastUpdatedUserId = service.getLastUpdaterUserId();
1082         service.setLastUpdaterUserId("wrong user id");
1083
1084         Either<Component, StorageOperationStatus> leftServiceOp = Either.left(service);
1085         when(toscaOperationFacade.getToscaElement(containerComponentId)).thenReturn(leftServiceOp);
1086         when(toscaOperationFacade.getToscaElement(eq(containerComponentId), any(ComponentParametersView.class)))
1087                 .thenReturn(leftServiceOp);
1088         when(janusGraphDao.rollback()).thenReturn(JanusGraphOperationStatus.OK);
1089         when(graphLockOperation.unlockComponent(Mockito.anyString(), eq(NodeTypeEnum.Service)))
1090                 .thenReturn(StorageOperationStatus.OK);
1091         when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Service)))
1092                 .thenReturn(StorageOperationStatus.OK);
1093
1094         result = componentInstanceBusinessLogic
1095                          .copyComponentInstance(inputComponentInstance, containerComponentId, componentInstanceId,
1096                                  USER_ID);
1097
1098         service.setLastUpdaterUserId(oldLastUpdatedUserId);
1099
1100         assertThat(result.isRight());
1101     }
1102
1103     @Test
1104     public void testCopyComponentInstanceComponentWrongState() {
1105         Either<Map<String, ComponentInstance>, ResponseFormat> result;
1106         ComponentInstance inputComponentInstance = createComponetInstanceFromComponent(resource);
1107         String containerComponentId = service.getUniqueId();
1108         String componentInstanceId = resource.getUniqueId();
1109         String oldServiceLastUpdatedUserId = service.getLastUpdaterUserId();
1110         service.setLastUpdaterUserId(USER_ID);
1111
1112         Either<Component, StorageOperationStatus> leftServiceOp = Either.left(service);
1113         when(toscaOperationFacade.getToscaElement(containerComponentId)).thenReturn(leftServiceOp);
1114         when(toscaOperationFacade.getToscaElement(eq(containerComponentId), any(ComponentParametersView.class)))
1115                 .thenReturn(leftServiceOp);
1116         when(janusGraphDao.rollback()).thenReturn(JanusGraphOperationStatus.OK);
1117         when(graphLockOperation.unlockComponent(Mockito.anyString(), eq(NodeTypeEnum.Service)))
1118                 .thenReturn(StorageOperationStatus.OK);
1119         when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Service)))
1120                 .thenReturn(StorageOperationStatus.OK);
1121         Either<Component, StorageOperationStatus> getComponentRes = Either.left(resource);
1122         result = componentInstanceBusinessLogic
1123                 .copyComponentInstance(inputComponentInstance, containerComponentId, componentInstanceId, USER_ID);
1124         service.setLastUpdaterUserId(oldServiceLastUpdatedUserId);
1125         assertThat(result.isRight());
1126     }
1127
1128     @Test
1129     public void testCopyComponentInstance() {
1130         Either<Map<String, ComponentInstance>, ResponseFormat> result;
1131         ComponentInstance inputComponentInstance = createComponetInstanceFromComponent(resource);
1132         String containerComponentId = service.getUniqueId();
1133         String componentInstanceId = resource.getUniqueId();
1134         String oldServiceLastUpdatedUserId = service.getLastUpdaterUserId();
1135         service.setLastUpdaterUserId(USER_ID);
1136         LifecycleStateEnum oldResourceLifeCycle = resource.getLifecycleState();
1137         resource.setLifecycleState(LifecycleStateEnum.CERTIFIED);
1138
1139         Either<Component, StorageOperationStatus> leftServiceOp = Either.left(service);
1140         when(toscaOperationFacade.getToscaElement(containerComponentId)).thenReturn(leftServiceOp);
1141         when(toscaOperationFacade.getToscaElement(eq(containerComponentId), any(ComponentParametersView.class)))
1142                 .thenReturn(leftServiceOp);
1143         when(graphLockOperation.unlockComponent(Mockito.anyString(), eq(NodeTypeEnum.Service)))
1144                 .thenReturn(StorageOperationStatus.OK);
1145         when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Service)))
1146                 .thenReturn(StorageOperationStatus.OK);
1147         Either<Component, StorageOperationStatus> getComponentRes = Either.left(resource);
1148         ImmutablePair<Component, String> pair = new ImmutablePair<>(resource, TO_INSTANCE_ID);
1149         Either<ImmutablePair<Component, String>, StorageOperationStatus> result2 = Either.left(pair);
1150         Either<Map<String, ArtifactDefinition>, StorageOperationStatus> getResourceDeploymentArtifacts = Either
1151                 .left(new HashMap<String, ArtifactDefinition>());
1152         StorageOperationStatus artStatus = StorageOperationStatus.OK;
1153
1154         result = componentInstanceBusinessLogic
1155                          .copyComponentInstance(inputComponentInstance, containerComponentId, componentInstanceId,
1156                                  USER_ID);
1157
1158         service.setLastUpdaterUserId(oldServiceLastUpdatedUserId);
1159         resource.setLifecycleState(oldResourceLifeCycle);
1160
1161         assertThat(result.isLeft());
1162     }
1163
1164     @Test
1165     public void testCreateOrUpdateAttributeValueForCopyPaste() {
1166         ComponentInstance serviceComponentInstance = createComponetInstanceFromComponent(service);
1167         ComponentInstanceProperty attribute = new ComponentInstanceProperty();
1168         attribute.setType("string");
1169         attribute.setUniqueId("testCreateOrUpdateAttributeValueForCopyPaste");
1170         SchemaDefinition def = Mockito.mock(SchemaDefinition.class);
1171         attribute.setSchema(def);
1172         LifecycleStateEnum oldLifeCycleState = service.getLifecycleState();
1173         String oldLastUpdatedUserId = service.getLastUpdaterUserId();
1174         service.setLastUpdaterUserId(USER_ID);
1175         service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1176
1177         Map<String, List<ComponentInstanceProperty>> instAttrsMap =
1178                 new HashMap<String, List<ComponentInstanceProperty>>();
1179         List<ComponentInstanceProperty> instAttrsList = new ArrayList<ComponentInstanceProperty>();
1180         ComponentInstanceProperty prop = new ComponentInstanceProperty();
1181         prop.setUniqueId(attribute.getUniqueId());
1182         instAttrsList.add(prop);
1183         instAttrsMap.put(toInstance.getUniqueId(), instAttrsList);
1184         service.setComponentInstancesAttributes(instAttrsMap);
1185
1186         Either<Component, StorageOperationStatus> serviceEitherLeft = Either.left(service);
1187         when(toscaOperationFacade.getToscaElement(serviceComponentInstance.getUniqueId(), JsonParseFlagEnum.ParseAll))
1188                 .thenReturn(serviceEitherLeft);
1189         when(toscaOperationFacade.updateComponentInstanceAttribute(service, toInstance.getUniqueId(), attribute))
1190                 .thenReturn(StorageOperationStatus.OK);
1191         when(toscaOperationFacade.updateComponentInstanceMetadataOfTopologyTemplate(service))
1192                 .thenReturn(serviceEitherLeft);
1193
1194         Either<ComponentInstanceProperty, ResponseFormat> result = Deencapsulation
1195                                                                            .invoke(componentInstanceBusinessLogic,
1196                                                                                    "createOrUpdateAttributeValueForCopyPaste",
1197                                                                                    ComponentTypeEnum.SERVICE,
1198                                                                                    serviceComponentInstance
1199                                                                                            .getUniqueId(),
1200                                                                                    toInstance.getUniqueId(), attribute,
1201                                                                                    USER_ID);
1202
1203         service.setLastUpdaterUserId(oldLastUpdatedUserId);
1204         service.setLifecycleState(oldLifeCycleState);
1205
1206         assertTrue(result.isLeft());
1207         ComponentInstanceProperty resultProp = result.left().value();
1208         assertEquals(resultProp.getPath().size(), 1);
1209         assertEquals(resultProp.getPath().get(0), toInstance.getUniqueId());
1210     }
1211
1212     @Test
1213     public void testUpdateComponentInstanceProperty() {
1214
1215         String containerComponentId = service.getUniqueId();
1216         String componentInstanceId = "dummy_id";
1217         ComponentInstanceProperty property = Mockito.mock(ComponentInstanceProperty.class);
1218
1219         Either<Component, StorageOperationStatus> getComponent = Either.left(service);
1220         when(toscaOperationFacade.getToscaElement(containerComponentId)).thenReturn(getComponent);
1221         StorageOperationStatus status = StorageOperationStatus.OK;
1222         when(toscaOperationFacade.updateComponentInstanceProperty(service, componentInstanceId, property))
1223                 .thenReturn(status);
1224         Either<Component, StorageOperationStatus> updateContainerRes = Either.left(service);
1225         when(toscaOperationFacade.updateComponentInstanceMetadataOfTopologyTemplate(service))
1226                 .thenReturn(updateContainerRes);
1227
1228         Either<String, ResponseFormat> result = Deencapsulation.invoke(componentInstanceBusinessLogic,
1229                 "updateComponentInstanceProperty", containerComponentId, componentInstanceId, property);
1230
1231         assertTrue(result.isLeft());
1232     }
1233
1234     @Test
1235     public void testGetInputListDefaultValue() {
1236         Component component = service;
1237         String inputId = "dummy_id";
1238         String defaultValue = "dummy_default_value";
1239         List<InputDefinition> newInputs = new ArrayList<InputDefinition>();
1240         InputDefinition in = new InputDefinition();
1241         in.setUniqueId(inputId);
1242         in.setDefaultValue(defaultValue);
1243         newInputs.add(in);
1244         List<InputDefinition> oldInputs = service.getInputs();
1245         service.setInputs(newInputs);
1246
1247         Either<String, ResponseFormat> result =
1248                 Deencapsulation.invoke(componentInstanceBusinessLogic, "getInputListDefaultValue", component, inputId);
1249
1250         service.setInputs(oldInputs);
1251
1252         assertEquals(result.left().value(), defaultValue);
1253     }
1254
1255     @Test
1256     public void testBatchDeleteComponentInstanceFailureWrongType() {
1257         Map<String, List<String>> result;
1258         List<String> componentInstanceIdList = new ArrayList<>();
1259         String containerComponentParam = "WRONG_TYPE";
1260         String containerComponentId = "containerComponentId";
1261         String componentInstanceId = "componentInstanceId";
1262         componentInstanceIdList.add(componentInstanceId);
1263         String userId = USER_ID;
1264         Map<String, List<String>> deleteErrorMap = new HashMap<>();
1265         List<String> deleteErrorIds = new ArrayList<>();
1266         deleteErrorIds.add(componentInstanceId);
1267         deleteErrorMap.put("deleteFailedIds", deleteErrorIds);
1268         Either<Component, StorageOperationStatus> cont = Either.left(service);
1269         when(componentsUtils.convertFromStorageResponse(eq(StorageOperationStatus.NOT_FOUND),eq(null)))
1270                 .thenReturn(ActionStatus.GENERAL_ERROR);
1271         when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1272                 .thenReturn(cont);
1273
1274         try{
1275         result = componentInstanceBusinessLogic
1276                 .batchDeleteComponentInstance(containerComponentParam, containerComponentId, componentInstanceIdList,
1277                         userId);
1278             }catch (ComponentException e){
1279                 assertEquals(e.getActionStatus().toString(), StorageOperationStatus.GENERAL_ERROR.toString());
1280             }
1281
1282 //        assertEquals(deleteErrorMap, result);
1283     }
1284
1285     @Test
1286     public void testBatchDeleteComponentInstanceFailureCompIds() {
1287         Map<String, List<String>> result = new HashMap<>();
1288         String containerComponentParam = ComponentTypeEnum.SERVICE_PARAM_NAME;
1289         String containerComponentId = "containerComponentId";
1290         String componentInstanceId = "componentInstanceId";
1291         List<String> componentInstanceIdList = new ArrayList<>();
1292         componentInstanceIdList.add(componentInstanceId);
1293         String userId = USER_ID;
1294         Map<String, List<String>> deleteErrorMap = new HashMap<>();
1295         List<String> deleteErrorIds = new ArrayList<>();
1296         deleteErrorIds.add(componentInstanceId);
1297         deleteErrorMap.put("deleteFailedIds", deleteErrorIds);
1298
1299         Either<Component, StorageOperationStatus> err = Either.right(StorageOperationStatus.GENERAL_ERROR);
1300         when(toscaOperationFacade.getToscaElement(eq(containerComponentId), any(ComponentParametersView.class)))
1301                 .thenReturn(err);
1302
1303         try {
1304             result = componentInstanceBusinessLogic
1305                     .batchDeleteComponentInstance(containerComponentParam, containerComponentId, componentInstanceIdList,
1306                             userId);
1307         }catch (ComponentException e){
1308             assertEquals(e.getActionStatus().toString(), StorageOperationStatus.GENERAL_ERROR.toString());
1309         }
1310 //        assertEquals(deleteErrorMap, result);
1311     }
1312
1313     @Test
1314     public void testBatchDeleteComponentInstanceSuccess() {
1315         Map<String, List<String>> result;
1316         String containerComponentParam = ComponentTypeEnum.SERVICE_PARAM_NAME;
1317         LifecycleStateEnum oldLifeCycleState = service.getLifecycleState();
1318         String oldLastUpdatedUserId = service.getLastUpdaterUserId();
1319         service.setLastUpdaterUserId(USER_ID);
1320         service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1321         String containerComponentId = service.getUniqueId();
1322         String componentInstanceId = TO_INSTANCE_ID;
1323         String userId = USER_ID;
1324         List<String> componentInstanceIdList = new ArrayList<>();
1325         componentInstanceIdList.add(componentInstanceId);
1326         Map<String, List<String>> deleteErrorMap = new HashMap<>();
1327         List<String> deleteErrorIds = new ArrayList<>();
1328         deleteErrorMap.put("deleteFailedIds", deleteErrorIds);
1329
1330         Either<Component, StorageOperationStatus> cont = Either.left(service);
1331         when(graphLockOperation.unlockComponent(Mockito.anyString(), eq(NodeTypeEnum.Service)))
1332                 .thenReturn(StorageOperationStatus.OK);
1333         when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Service)))
1334                 .thenReturn(StorageOperationStatus.OK);
1335         ImmutablePair<Component, String> pair = new ImmutablePair<>(resource, TO_INSTANCE_ID);
1336         Either<ImmutablePair<Component, String>, StorageOperationStatus> result2 = Either.left(pair);
1337         when(toscaOperationFacade.deleteComponentInstanceFromTopologyTemplate(service, componentInstanceId))
1338                 .thenReturn(result2);
1339         when(toscaOperationFacade.getToscaElement(eq(service.getUniqueId()), any(ComponentParametersView.class)))
1340                 .thenReturn(cont);
1341         when(janusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
1342
1343         result = componentInstanceBusinessLogic
1344                          .batchDeleteComponentInstance(containerComponentParam, containerComponentId,
1345                                  componentInstanceIdList, userId);
1346
1347         service.setLastUpdaterUserId(oldLastUpdatedUserId);
1348         service.setLifecycleState(oldLifeCycleState);
1349         assertEquals(deleteErrorMap, result);
1350     }
1351
1352     @Test
1353     public void testDissociateRIFromRIFailDissociate() {
1354
1355         List<RequirementCapabilityRelDef> result;
1356         RequirementCapabilityRelDef ref = new RequirementCapabilityRelDef();
1357         ref.setFromNode(FROM_INSTANCE_ID);
1358         ref.setToNode(TO_INSTANCE_ID);
1359         List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1360         CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
1361         RelationshipInfo ri = new RelationshipInfo();
1362         ri.setRequirement(REQUIREMENT_NAME);
1363         relationship.setRelation(ri);
1364         relationships.add(relationship);
1365         ref.setRelationships(relationships);
1366         List<RequirementCapabilityRelDef> requirementDefList = new ArrayList<>();
1367         requirementDefList.add(ref);
1368         ComponentTypeEnum componentTypeEnum = service.getComponentType();
1369         String componentId = service.getUniqueId();
1370         String userId = USER_ID;
1371         LifecycleStateEnum oldLifeCycleState = service.getLifecycleState();
1372         String oldLastUpdatedUserId = service.getLastUpdaterUserId();
1373         service.setLastUpdaterUserId(USER_ID);
1374         service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1375
1376         Either<Component, StorageOperationStatus> cont = Either.left(service);
1377         when(toscaOperationFacade.getToscaElement(eq(service.getUniqueId()), any(ComponentParametersView.class)))
1378                 .thenReturn(cont);
1379         when(graphLockOperation.unlockComponent(Mockito.anyString(), eq(NodeTypeEnum.Service)))
1380                 .thenReturn(StorageOperationStatus.OK);
1381         when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Service)))
1382                 .thenReturn(StorageOperationStatus.OK);
1383         Either<RequirementCapabilityRelDef, StorageOperationStatus> resultEither;
1384         resultEither = Either.right(StorageOperationStatus.OK);
1385         when(componentsUtils.convertFromStorageResponseForResourceInstance(eq(StorageOperationStatus.OK),eq(true)))
1386                 .thenReturn(ActionStatus.GENERAL_ERROR);
1387         when(toscaOperationFacade.dissociateResourceInstances(componentId, ref)).thenReturn(resultEither);
1388
1389     try{
1390         result = componentInstanceBusinessLogic
1391                          .batchDissociateRIFromRI(componentId, userId, requirementDefList, componentTypeEnum);
1392     }catch (ComponentException e){
1393         assertEquals(e.getActionStatus().toString(), StorageOperationStatus.GENERAL_ERROR.toString());
1394     }
1395
1396         service.setLastUpdaterUserId(oldLastUpdatedUserId);
1397         service.setLifecycleState(oldLifeCycleState);
1398
1399 //        assertEquals(new ArrayList<>(), result);
1400     }
1401
1402     @Test
1403     public void testDissociateRIFromRISuccess() {
1404
1405         List<RequirementCapabilityRelDef> result;
1406         RequirementCapabilityRelDef ref = new RequirementCapabilityRelDef();
1407         List<RequirementCapabilityRelDef> requirementDefList = new ArrayList<>();
1408         requirementDefList.add(ref);
1409         ComponentTypeEnum componentTypeEnum = service.getComponentType();
1410         String componentId = service.getUniqueId();
1411         String userId = USER_ID;
1412         LifecycleStateEnum oldLifeCycleState = service.getLifecycleState();
1413         String oldLastUpdatedUserId = service.getLastUpdaterUserId();
1414         service.setLastUpdaterUserId(USER_ID);
1415         service.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1416
1417         Either<Component, StorageOperationStatus> cont = Either.left(service);
1418         when(toscaOperationFacade.getToscaElement(eq(service.getUniqueId()), any(ComponentParametersView.class)))
1419                 .thenReturn(cont);
1420         when(graphLockOperation.unlockComponent(Mockito.anyString(), eq(NodeTypeEnum.Service)))
1421                 .thenReturn(StorageOperationStatus.OK);
1422         when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Service)))
1423                 .thenReturn(StorageOperationStatus.OK);
1424         Either<RequirementCapabilityRelDef, StorageOperationStatus> resultEither;
1425         resultEither = Either.left(ref);
1426         when(toscaOperationFacade.dissociateResourceInstances(componentId, ref)).thenReturn(resultEither);
1427
1428         result = componentInstanceBusinessLogic
1429                          .batchDissociateRIFromRI(componentId, userId, requirementDefList, componentTypeEnum);
1430
1431         service.setLastUpdaterUserId(oldLastUpdatedUserId);
1432         service.setLifecycleState(oldLifeCycleState);
1433
1434         assertEquals(requirementDefList, result);
1435     }
1436
1437     @Test
1438     public void testGetComponentInstancePropertyByPolicyId_success() {
1439         Optional<ComponentInstanceProperty> propertyCandidate =
1440                 getComponentInstanceProperty(PROP_NAME);
1441
1442         Assert.assertTrue(propertyCandidate.isPresent());
1443         Assert.assertEquals(propertyCandidate.get().getName(), PROP_NAME);
1444     }
1445
1446     @Test
1447     public void testGetComponentInstancePropertyByPolicyId_failure() {
1448         Optional<ComponentInstanceProperty> propertyCandidate =
1449                 getComponentInstanceProperty(NON_EXIST_NAME);
1450
1451         Assert.assertEquals(propertyCandidate, Optional.empty());
1452     }
1453
1454     private Optional<ComponentInstanceProperty> getComponentInstanceProperty(String propertyName) {
1455         ComponentInstanceProperty componentInstanceProperty = new ComponentInstanceProperty();
1456         componentInstanceProperty.setName(propertyName);
1457
1458         PolicyDefinition policyDefinition = getPolicyDefinition();
1459         componentInstanceProperty.setGetPolicyValues(policyDefinition.getGetPolicyValues());
1460
1461         service.setComponentInstancesProperties(
1462                 Collections.singletonMap(COMPONENT_INST_ID, Collections.singletonList(componentInstanceProperty)));
1463
1464         return componentInstanceBusinessLogic.getComponentInstancePropertyByPolicyId(service, policyDefinition);
1465     }
1466
1467     private PolicyDefinition getPolicyDefinition() {
1468         PolicyDefinition policyDefinition = new PolicyDefinition();
1469         policyDefinition.setInstanceUniqueId(COMPONENT_INST_ID);
1470         policyDefinition.setName(PROP_NAME);
1471
1472         GetPolicyValueDataDefinition getPolicy = new GetPolicyValueDataDefinition();
1473         getPolicy.setPropertyName(PROP_NAME);
1474
1475         List<GetPolicyValueDataDefinition> getPolicies = new ArrayList<>();
1476         getPolicies.add(getPolicy);
1477         policyDefinition.setGetPolicyValues(getPolicies);
1478
1479         return policyDefinition;
1480     }
1481
1482     private ComponentInstance createComponetInstanceFromComponent(Component component) {
1483         ComponentInstance componentInst = new ComponentInstance();
1484         componentInst.setUniqueId(component.getUniqueId());
1485         componentInst.setComponentUid(component.getUniqueId() + "_test");
1486         componentInst.setPosX("10");
1487         componentInst.setPosY("10");
1488         componentInst.setCapabilities(component.getCapabilities());
1489         componentInst.setRequirements(component.getRequirements());
1490         componentInst.setArtifacts(component.getArtifacts());
1491         componentInst.setDeploymentArtifacts(component.getDeploymentArtifacts());
1492         return componentInst;
1493     }
1494 }