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

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