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