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