gerrit.onap Code Review - sdc.git/blob

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