Code Review / sdc.git / blob
? search:


45b938f9883477a7cfc3029a031ab7d5e6e4cca3
[sdc.git] /
1 package org.openecomp.sdc.be.components.impl;
2
3 import static org.junit.Assert.assertTrue;
4 import static org.mockito.ArgumentMatchers.any;
5 import static org.mockito.ArgumentMatchers.anySet;
6 import static org.mockito.ArgumentMatchers.anyString;
7 import static org.mockito.ArgumentMatchers.eq;
8 import static org.mockito.Mockito.when;
9
10 import java.util.ArrayList;
11 import java.util.HashMap;
12 import java.util.HashSet;
13 import java.util.List;
14 import java.util.Map;
15 import java.util.Set;
16 import java.util.function.BiPredicate;
17
18 import org.apache.commons.lang3.tuple.ImmutablePair;
19 import org.apache.commons.lang3.tuple.Pair;
20 import org.assertj.core.util.Lists;
21 import org.junit.Assert;
22 import org.junit.Before;
23 import org.junit.Test;
24 import org.mockito.Mock;
25 import org.mockito.Mockito;
26 import org.mockito.MockitoAnnotations;
27 import org.openecomp.sdc.be.components.validation.UserValidations;
28 import org.openecomp.sdc.be.dao.api.ActionStatus;
29 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
30 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
31 import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
32 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
33 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathElementDataDefinition;
34 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
35 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
36 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
37 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
38 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
39 import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
40 import org.openecomp.sdc.be.impl.ComponentsUtils;
41 import org.openecomp.sdc.be.impl.ServletUtils;
42 import org.openecomp.sdc.be.info.CreateAndAssotiateInfo;
43 import org.openecomp.sdc.be.model.CapabilityDefinition;
44 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
45 import org.openecomp.sdc.be.model.Component;
46 import org.openecomp.sdc.be.model.ComponentInstance;
47 import org.openecomp.sdc.be.model.ComponentInstanceInput;
48 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
49 import org.openecomp.sdc.be.model.ComponentParametersView;
50 import org.openecomp.sdc.be.model.RelationshipImpl;
51 import org.openecomp.sdc.be.model.RelationshipInfo;
52 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
53 import org.openecomp.sdc.be.model.RequirementDefinition;
54 import org.openecomp.sdc.be.model.Resource;
55 import org.openecomp.sdc.be.model.Service;
56 import org.openecomp.sdc.be.model.User;
57 import org.openecomp.sdc.be.model.jsontitan.operations.ForwardingPathOperation;
58 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
59 import org.openecomp.sdc.be.model.operations.api.IComponentInstanceOperation;
60 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
61 import org.openecomp.sdc.be.model.operations.impl.ArtifactOperation;
62 import org.openecomp.sdc.be.resources.data.ComponentInstanceData;
63 import org.openecomp.sdc.be.user.UserBusinessLogic;
64 import org.openecomp.sdc.exception.ResponseFormat;
65 import org.openecomp.sdc.common.datastructure.Wrapper;
66
67 import fj.data.Either;
68 import javassist.CodeConverter.ArrayAccessReplacementMethodNames;
69 import mockit.Deencapsulation;
70
71 import java.util.*;
72
73 /**
74  * The test suite designed for test functionality of
75  * ComponentInstanceBusinessLogic class
76  */
77 public class ComponentInstanceBusinessLogicTest {
78
79         private final static String USER_ID = "jh0003";
80         private final static String COMPONENT_ID = "componentId";
81         private final static String TO_INSTANCE_ID = "toInstanceId";
82         private final static String FROM_INSTANCE_ID = "fromInstanceId";
83         private final static String RELATION_ID = "relationId";
84         private final static String CAPABILITY_OWNER_ID = "capabilityOwnerId";
85         private final static String CAPABILITY_UID = "capabilityUid";
86         private final static String CAPABILITY_NAME = "capabilityName";
87         private final static String REQUIREMENT_OWNER_ID = "requirementOwnerId";
88         private final static String REQUIREMENT_UID = "requirementUid";
89         private final static String REQUIREMENT_NAME = "requirementName";
90         private final static String RELATIONSHIP_TYPE = "relationshipType";
91
92         private static ComponentsUtils componentsUtils;
93         private static ServletUtils servletUtils;
94         private static ResponseFormat responseFormat;
95         private static ToscaOperationFacade toscaOperationFacade;
96         private static IComponentInstanceOperation componentInstanceOperation;
97         private static UserBusinessLogic userAdmin;
98
99         private static ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
100         private static ForwardingPathOperation forwardingPathOperation;
101         private static User user;
102         private static UserValidations userValidations;
103         private static Component service;
104         private static Component resource;
105         private static ComponentInstance toInstance;
106         private static ComponentInstance fromInstance;
107         private static CapabilityDataDefinition capability;
108         private static RequirementDataDefinition requirement;
109         private static RequirementCapabilityRelDef relation;
110         private static BaseBusinessLogic baseBusinessLogic;
111         private static ArtifactsBusinessLogic artifactsBusinessLogic;
112         private static ToscaDataDefinition toscaDataDefinition;
113
114         @Before
115         public void init() {
116                 createMocks();
117                 setMocks();
118                 stubMethods();
119                 createComponents();
120                 MockitoAnnotations.initMocks(this);
121         }
122
123         @Test
124         public void testGetRelationByIdSuccess() {
125                 getServiceRelationByIdSuccess(service);
126                 getServiceRelationByIdSuccess(resource);
127         }
128
129         @Test
130         public void testGetRelationByIdUserValidationFailure() {
131                 getServiceRelationByIdUserValidationFailure(service);
132                 getServiceRelationByIdUserValidationFailure(resource);
133         }
134
135         @Test
136         public void testGetRelationByIdComponentNotFoundFailure() {
137                 getRelationByIdComponentNotFoundFailure(service);
138                 getRelationByIdComponentNotFoundFailure(resource);
139         }
140
141         
142         @Test
143         public void testForwardingPathOnVersionChange() {
144                 getforwardingPathOnVersionChange();
145         }
146
147         private void getforwardingPathOnVersionChange() {
148                 String containerComponentParam = "services";
149                 String containerComponentID = "121-cont";
150                 String componentInstanceID = "121-cont-1-comp";
151                 Service component = new Service();
152                 Map<String, ForwardingPathDataDefinition> forwardingPaths = generateForwardingPath(componentInstanceID);
153
154                 // Add existing componentInstance to component
155                 List<ComponentInstance> componentInstanceList = new ArrayList<>();
156                 ComponentInstance oldComponentInstance = new ComponentInstance();
157                 oldComponentInstance.setName("OLD_COMP_INSTANCE");
158                 oldComponentInstance.setUniqueId(componentInstanceID);
159                 oldComponentInstance.setToscaPresentationValue(JsonPresentationFields.CI_COMPONENT_UID, "1-comp");
160                 componentInstanceList.add(oldComponentInstance);
161                 component.setComponentInstances(componentInstanceList);
162                 component.setForwardingPaths(forwardingPaths);
163
164                 List<ComponentInstance> componentInstanceListNew = new ArrayList<>();
165                 ComponentInstance newComponentInstance = new ComponentInstance();
166                 String new_Comp_UID = "2-comp";
167                 newComponentInstance.setToscaPresentationValue(JsonPresentationFields.CI_COMPONENT_UID, new_Comp_UID);
168                 newComponentInstance.setUniqueId(new_Comp_UID);
169                 componentInstanceListNew.add(newComponentInstance);
170                 Component component2 = new Service();
171                 component2.setComponentInstances(componentInstanceListNew);
172
173                 // Mock for getting component
174                 when(toscaOperationFacade.getToscaElement(eq(containerComponentID), any(ComponentParametersView.class)))
175                                 .thenReturn(Either.left(component));
176                 when(toscaOperationFacade.validateComponentExists(any(String.class))).thenReturn(Either.left(Boolean.TRUE));
177                 // Mock for getting component for componentInstance
178                 when(toscaOperationFacade.getToscaFullElement(eq("1-comp"))).thenReturn(Either.left(component));
179                 when(toscaOperationFacade.getToscaFullElement(eq(new_Comp_UID))).thenReturn(Either.left(component2));
180
181                 Either<Set<String>, ResponseFormat> resultOp = componentInstanceBusinessLogic.forwardingPathOnVersionChange(
182                                 containerComponentParam, containerComponentID, componentInstanceID, newComponentInstance);
183                 Assert.assertEquals(1, resultOp.left().value().size());
184                 Assert.assertEquals("FP-ID-1", resultOp.left().value().iterator().next());
185
186         }
187
188         @Test
189         public void testDeleteForwardingPathsWhenComponentinstanceDeleted() {
190
191                 ComponentTypeEnum containerComponentType = ComponentTypeEnum.findByParamName("services");
192                 String containerComponentID = "Service-comp";
193                 String componentInstanceID = "NodeA1";
194                 Service component = new Service();
195
196                 component.addForwardingPath(createPath("path1", "NodeA1", "NodeB1", "1"));
197                 component.addForwardingPath(createPath("Path2", "NodeA2", "NodeB2", "2"));
198                 when(toscaOperationFacade.getToscaElement(eq(containerComponentID), any(ComponentParametersView.class)))
199                                 .thenReturn(Either.left(component));
200                 when(toscaOperationFacade.getToscaElement(eq(containerComponentID))).thenReturn(Either.left(component));
201                 when(forwardingPathOperation.deleteForwardingPath(any(Service.class), anySet()))
202                                 .thenReturn(Either.left(new HashSet<>()));
203                 Either<ComponentInstance, ResponseFormat> responseFormatEither = componentInstanceBusinessLogic
204                                 .deleteForwardingPathsRelatedTobeDeletedComponentInstance(containerComponentID, componentInstanceID,
205                                                 containerComponentType, Either.left(new ComponentInstance()));
206                 Assert.assertTrue(responseFormatEither.isLeft());
207
208         }
209
210         @Test
211         public void testDeleteForwardingPathsWhenErrorInComponentinstanceDelete() {
212
213                 ComponentTypeEnum containerComponentType = ComponentTypeEnum.findByParamName("services");
214                 String containerComponentID = "Service-comp";
215                 String componentInstanceID = "NodeA1";
216                 Service component = new Service();
217
218                 component.addForwardingPath(createPath("path1", "NodeA1", "NodeB1", "1"));
219                 component.addForwardingPath(createPath("Path2", "NodeA2", "NodeB2", "2"));
220                 when(toscaOperationFacade.getToscaElement(eq(containerComponentID), any(ComponentParametersView.class)))
221                                 .thenReturn(Either.left(component));
222                 when(toscaOperationFacade.getToscaElement(eq(containerComponentID))).thenReturn(Either.left(component));
223                 when(forwardingPathOperation.deleteForwardingPath(any(Service.class), anySet()))
224                                 .thenReturn(Either.left(new HashSet<>()));
225                 Either<ComponentInstance, ResponseFormat> responseFormatEither = componentInstanceBusinessLogic
226                                 .deleteForwardingPathsRelatedTobeDeletedComponentInstance(containerComponentID, componentInstanceID,
227                                                 containerComponentType, Either.right(new ResponseFormat()));
228                 Assert.assertTrue(responseFormatEither.isRight());
229
230         }
231
232         private ForwardingPathDataDefinition createPath(String pathName, String fromNode, String toNode, String uniqueId) {
233                 ForwardingPathDataDefinition forwardingPath = new ForwardingPathDataDefinition(pathName);
234                 forwardingPath.setProtocol("protocol");
235                 forwardingPath.setDestinationPortNumber("port");
236                 forwardingPath.setUniqueId(uniqueId);
237                 ListDataDefinition<ForwardingPathElementDataDefinition> forwardingPathElementListDataDefinition = new ListDataDefinition<>();
238                 forwardingPathElementListDataDefinition.add(new ForwardingPathElementDataDefinition(fromNode, toNode,
239                                 "nodeAcpType", "nodeBcpType", "nodeDcpName", "nodeBcpName"));
240                 forwardingPath.setPathElements(forwardingPathElementListDataDefinition);
241
242                 return forwardingPath;
243         }
244
245         private Map<String, ForwardingPathDataDefinition> generateForwardingPath(String componentInstanceID) {
246                 ForwardingPathDataDefinition forwardingPath = new ForwardingPathDataDefinition("fpName");
247                 String protocol = "protocol";
248                 forwardingPath.setProtocol(protocol);
249                 forwardingPath.setDestinationPortNumber("DestinationPortNumber");
250                 forwardingPath.setUniqueId("FP-ID-1");
251                 ListDataDefinition<ForwardingPathElementDataDefinition> forwardingPathElementListDataDefinition = new ListDataDefinition<>();
252                 forwardingPathElementListDataDefinition.add(new ForwardingPathElementDataDefinition(componentInstanceID,
253                                 "nodeB", "nodeA_FORWARDER_CAPABILITY", "nodeBcpType", "nodeDcpName", "nodeBcpName"));
254                 forwardingPath.setPathElements(forwardingPathElementListDataDefinition);
255                 Map<String, ForwardingPathDataDefinition> forwardingPaths = new HashMap<>();
256                 forwardingPaths.put("1122", forwardingPath);
257                 return forwardingPaths;
258         }
259
260         @SuppressWarnings("unchecked")
261         private void getServiceRelationByIdSuccess(Component component) {
262                 Either<User, ActionStatus> eitherCreator = Either.left(user);
263                 when(userAdmin.getUser(eq(USER_ID), eq(false))).thenReturn(eitherCreator);
264                 Either<Component, StorageOperationStatus> getComponentRes = Either.left(component);
265                 when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class)))
266                                 .thenReturn(getComponentRes);
267
268                 Either<RequirementDataDefinition, StorageOperationStatus> getfulfilledRequirementRes = Either.left(requirement);
269                 when(toscaOperationFacade.getFulfilledRequirementByRelation(eq(COMPONENT_ID), eq(FROM_INSTANCE_ID),
270                                 eq(relation), any(BiPredicate.class))).thenReturn(getfulfilledRequirementRes);
271
272                 Either<CapabilityDataDefinition, StorageOperationStatus> getfulfilledCapabilityRes = Either.left(capability);
273                 when(toscaOperationFacade.getFulfilledCapabilityByRelation(eq(COMPONENT_ID), eq(FROM_INSTANCE_ID), eq(relation),
274                                 any(BiPredicate.class))).thenReturn(getfulfilledCapabilityRes);
275
276                 Either<RequirementCapabilityRelDef, ResponseFormat> response = componentInstanceBusinessLogic
277                                 .getRelationById(COMPONENT_ID, RELATION_ID, USER_ID, component.getComponentType());
278                 assertTrue(response.isLeft());
279         }
280
281         private void getServiceRelationByIdUserValidationFailure(Component component) {
282                 // Either<User, ActionStatus> eitherCreator =
283                 // Either.right(ActionStatus.USER_NOT_FOUND);
284                 // when(userAdmin.getUser(eq(USER_ID),
285                 // eq(false))).thenReturn(eitherCreator);
286                 when(userValidations.validateUserExists(eq(USER_ID), eq("get relation by Id"), eq(false)))
287                                 .thenReturn(Either.right(new ResponseFormat(404)));
288                 Either<RequirementCapabilityRelDef, ResponseFormat> response = componentInstanceBusinessLogic
289                                 .getRelationById(COMPONENT_ID, RELATION_ID, USER_ID, component.getComponentType());
290                 assertTrue(response.isRight());
291         }
292
293         private void getRelationByIdComponentNotFoundFailure(Component component) {
294                 Either<User, ActionStatus> eitherCreator = Either.left(user);
295                 when(userAdmin.getUser(eq(USER_ID), eq(false))).thenReturn(eitherCreator);
296                 Either<Component, StorageOperationStatus> getComponentRes = Either.right(StorageOperationStatus.NOT_FOUND);
297                 when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class)))
298                                 .thenReturn(getComponentRes);
299
300                 Either<RequirementCapabilityRelDef, ResponseFormat> response = componentInstanceBusinessLogic
301                                 .getRelationById(COMPONENT_ID, RELATION_ID, USER_ID, component.getComponentType());
302                 assertTrue(response.isRight());
303         }
304
305         private static void createMocks() {
306                 componentsUtils = Mockito.mock(ComponentsUtils.class);
307                 servletUtils = Mockito.mock(ServletUtils.class);
308                 responseFormat = Mockito.mock(ResponseFormat.class);
309                 toscaOperationFacade = Mockito.mock(ToscaOperationFacade.class);
310                 userAdmin = Mockito.mock(UserBusinessLogic.class);
311                 user = Mockito.mock(User.class);
312                 baseBusinessLogic = Mockito.mock(BaseBusinessLogic.class);
313                 userValidations = Mockito.mock(UserValidations.class);
314                 forwardingPathOperation = Mockito.mock(ForwardingPathOperation.class);
315                 componentInstanceOperation = Mockito.mock(IComponentInstanceOperation.class);
316                 artifactsBusinessLogic = Mockito.mock(ArtifactsBusinessLogic.class);
317                 toscaDataDefinition = Mockito.mock(ToscaDataDefinition.class);
318         }
319
320         private static void setMocks() {
321                 componentInstanceBusinessLogic = new ComponentInstanceBusinessLogic();
322                 componentInstanceBusinessLogic.setToscaOperationFacade(toscaOperationFacade);
323                 componentInstanceBusinessLogic.setUserAdmin(userAdmin);
324                 componentInstanceBusinessLogic.setComponentsUtils(componentsUtils);
325                 componentInstanceBusinessLogic.setUserValidations(userValidations);
326                 componentInstanceBusinessLogic.setForwardingPathOperation(forwardingPathOperation);
327         }
328
329         private static void stubMethods() {
330                 when(servletUtils.getComponentsUtils()).thenReturn(componentsUtils);
331                 when(userValidations.validateUserExists(eq(USER_ID), eq("get relation by Id"), eq(false)))
332                                 .thenReturn(Either.left(user));
333                 when(componentsUtils.getResponseFormat(eq(ActionStatus.RELATION_NOT_FOUND), eq(RELATION_ID), eq(COMPONENT_ID)))
334                                 .thenReturn(responseFormat);
335                 Either<User, ActionStatus> eitherGetUser = Either.left(user);
336                 when(userAdmin.getUser("jh0003", false)).thenReturn(eitherGetUser);
337                 when(userValidations.validateUserExists(eq(user.getUserId()), anyString(), eq(false)))
338                                 .thenReturn(Either.left(user));
339         }
340
341         private static void createComponents() {
342                 createRelation();
343                 createInstances();
344                 createService();
345                 createResource();
346         }
347
348         private static Component createResource() {
349                 resource = new Resource();
350                 resource.setUniqueId(COMPONENT_ID);
351                 resource.setComponentInstancesRelations(Lists.newArrayList(relation));
352                 resource.setComponentInstances(Lists.newArrayList(toInstance, fromInstance));
353                 resource.setCapabilities(toInstance.getCapabilities());
354                 resource.setRequirements(fromInstance.getRequirements());
355                 resource.setComponentType(ComponentTypeEnum.RESOURCE);
356                 return resource;
357         }
358
359         private static Component createService() {
360                 service = new Service();
361                 service.setUniqueId(COMPONENT_ID);
362                 service.setComponentInstancesRelations(Lists.newArrayList(relation));
363                 service.setComponentInstances(Lists.newArrayList(toInstance, fromInstance));
364                 service.setCapabilities(toInstance.getCapabilities());
365                 service.setRequirements(fromInstance.getRequirements());
366                 service.setComponentType(ComponentTypeEnum.SERVICE);
367                 return service;
368         }
369
370         private static ComponentInstance createInstances() {
371                 toInstance = new ComponentInstance();
372                 toInstance.setUniqueId(TO_INSTANCE_ID);
373                 toInstance.setComponentUid("uuuiiid");
374                 toInstance.setName("tests");
375
376                 fromInstance = new ComponentInstance();
377                 fromInstance.setUniqueId(FROM_INSTANCE_ID);
378
379                 capability = new CapabilityDataDefinition();
380                 capability.setOwnerId(CAPABILITY_OWNER_ID);
381                 capability.setUniqueId(CAPABILITY_UID);
382                 capability.setName(CAPABILITY_NAME);
383
384                 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
385                 capabilities.put(capability.getName(), Lists.newArrayList(new CapabilityDefinition(capability)));
386
387                 requirement = new RequirementDataDefinition();
388                 requirement.setOwnerId(REQUIREMENT_OWNER_ID);
389                 requirement.setUniqueId(REQUIREMENT_UID);
390                 requirement.setName(REQUIREMENT_NAME);
391                 requirement.setRelationship(RELATIONSHIP_TYPE);
392
393                 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
394                 requirements.put(requirement.getCapability(), Lists.newArrayList(new RequirementDefinition(requirement)));
395
396                 toInstance.setCapabilities(capabilities);
397                 fromInstance.setRequirements(requirements);
398                 return toInstance;
399         }
400
401         private static void createRelation() {
402
403                 relation = new RequirementCapabilityRelDef();
404                 CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
405                 RelationshipInfo relationInfo = new RelationshipInfo();
406                 relationInfo.setId(RELATION_ID);
407                 relationship.setRelation(relationInfo);
408
409                 relation.setRelationships(Lists.newArrayList(relationship));
410                 relation.setToNode(TO_INSTANCE_ID);
411                 relation.setFromNode(FROM_INSTANCE_ID);
412
413                 relationInfo.setCapabilityOwnerId(CAPABILITY_OWNER_ID);
414                 relationInfo.setCapabilityUid(CAPABILITY_UID);
415                 relationInfo.setCapability(CAPABILITY_NAME);
416                 relationInfo.setRequirementOwnerId(REQUIREMENT_OWNER_ID);
417                 relationInfo.setRequirementUid(REQUIREMENT_UID);
418                 relationInfo.setRequirement(REQUIREMENT_NAME);
419                 RelationshipImpl relationshipImpl = new RelationshipImpl();
420                 relationshipImpl.setType(RELATIONSHIP_TYPE);
421                 relationInfo.setRelationships(relationshipImpl);
422         }
423
424         ///////////////////////////////////////////////////////////////////////////////
425         /////////////////////////////new test//////////////////////////////////////////
426         ///////////////////////////////////////////////////////////////////////////////
427         
428         
429         private ComponentInstanceBusinessLogic createTestSubject() {
430                         return componentInstanceBusinessLogic;
431         }
432
433         
434
435
436         
437         @Test
438         public void testChangeServiceProxyVersion() throws Exception {
439                 ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
440                 String containerComponentType = "";
441                 String containerComponentId = "";
442                 String serviceProxyId = "";
443                 String userId = user.getUserId();
444                 Either<ComponentInstance, ResponseFormat> result;
445
446                 // default test
447                 componentInstanceBusinessLogic = createTestSubject();
448                 result = componentInstanceBusinessLogic.changeServiceProxyVersion(containerComponentType, containerComponentId, serviceProxyId,
449                                 userId);
450         }
451
452
453
454
455         
456
457         
458         @Test
459         public void testCreateServiceProxy() throws Exception {
460                 ComponentInstanceBusinessLogic testSubject;
461                 String containerComponentType = "";
462                 String containerComponentId = "";
463                 String userId = user.getUserId();
464                 ComponentInstance componentInstance = createInstances();
465                 Either<ComponentInstance, ResponseFormat> result;
466
467                 // default test
468                 testSubject = createTestSubject();
469                 result = testSubject.createServiceProxy(containerComponentType, containerComponentId, userId,
470                                 componentInstance);
471         }
472
473
474
475         
476         
477         @Test
478         public void testDeleteForwardingPathsRelatedTobeDeletedComponentInstance() throws Exception {
479                 ComponentInstanceBusinessLogic testSubject;
480                 String containerComponentId = "";
481                 String componentInstanceId = "";
482                 ComponentTypeEnum containerComponentType = ComponentTypeEnum.RESOURCE;
483                 Either<ComponentInstance, ResponseFormat> resultOp = null;
484                 Either<ComponentInstance, ResponseFormat> result;
485
486                 // default test
487                 testSubject = createTestSubject();
488                 result = testSubject.deleteForwardingPathsRelatedTobeDeletedComponentInstance(containerComponentId,
489                                 componentInstanceId, containerComponentType, resultOp);
490         }
491
492         
493         @Test
494         public void testDeleteServiceProxy() throws Exception {
495                 ComponentInstanceBusinessLogic testSubject;
496                 String containerComponentType = "";
497                 String containerComponentId = "";
498                 String serviceProxyId = "";
499                 String userId = user.getUserId();
500                 Either<ComponentInstance, ResponseFormat> result;
501
502                 // default test
503                 testSubject = createTestSubject();
504                 result = testSubject.deleteServiceProxy(containerComponentType, containerComponentId, serviceProxyId, userId);
505         }
506
507
508         
509
510
511         
512         @Test
513         public void testGetComponentInstanceInputsByInputId() throws Exception {
514                 ComponentInstanceBusinessLogic testSubject;
515                 Component component = new Service();
516                 String inputId = "";
517                 List<ComponentInstanceInput> result;
518
519                 // default test
520                 testSubject = createTestSubject();
521                 result = testSubject.getComponentInstanceInputsByInputId(component, inputId);
522         }
523
524
525         
526         @Test
527         public void testGetComponentInstancePropertiesByInputId() throws Exception {
528                 ComponentInstanceBusinessLogic testSubject;
529                 Component component = new Service();
530                 String inputId = "";
531                 List<ComponentInstanceProperty> result;
532
533                 // default test
534                 testSubject = createTestSubject();
535                 result = testSubject.getComponentInstancePropertiesByInputId(component, inputId);
536         }
537
538         
539         @Test
540         public void testGetRelationById() throws Exception {
541                 ComponentInstanceBusinessLogic testSubject;
542                 String componentId = "";
543                 String relationId = "";
544                 String userId = user.getUserId();
545                 ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE_INSTANCE;
546                 Either<RequirementCapabilityRelDef, ResponseFormat> result;
547
548                 // default test
549                 testSubject = createTestSubject();
550                 result = testSubject.getRelationById(componentId, relationId, userId, componentTypeEnum);
551         }
552
553         
554
555
556         
557         @Test
558         public void testCreateComponentInstance_1() throws Exception {
559         ComponentInstanceBusinessLogic testSubject;String containerComponentParam = "";
560         String containerComponentId = "";
561         String userId = user.getUserId();
562         ComponentInstance resourceInstance = null;
563         boolean inTransaction = false;
564         boolean needLock = false;
565         Either<ComponentInstance,ResponseFormat> result;
566         
567         // default test
568         testSubject=createTestSubject();result=testSubject.createComponentInstance(containerComponentParam, containerComponentId, userId, resourceInstance, inTransaction, needLock);
569         }
570
571         
572
573
574         
575         @Test
576         public void testCreateAndAssociateRIToRI() throws Exception {
577         ComponentInstanceBusinessLogic testSubject;
578         
579         String containerComponentParam = "";
580         String containerComponentId = "";
581         String userId = user.getUserId();
582         CreateAndAssotiateInfo createAndAssotiateInfo = new CreateAndAssotiateInfo(null, null);
583         Either<CreateAndAssotiateInfo,ResponseFormat> result;
584         
585         // default test
586         testSubject=createTestSubject();result=testSubject.createAndAssociateRIToRI(containerComponentParam, containerComponentId, userId, createAndAssotiateInfo);
587         }
588         
589         @Test
590         public void testGetOriginComponentFromComponentInstance_1() throws Exception {
591         ComponentInstanceBusinessLogic testSubject;
592         Component compoent = createResource();
593         String componentInstanceName = "";
594         String origComponetId = compoent.getUniqueId();
595         Either<Component, StorageOperationStatus> oldResourceRes = Either.left(compoent);
596         when(toscaOperationFacade.getToscaFullElement(compoent.getUniqueId())).thenReturn(oldResourceRes);
597         Either<Component,ResponseFormat> result;
598         
599         // default test
600         testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "getOriginComponentFromComponentInstance", new Object[]{componentInstanceName, origComponetId});
601         }
602
603         
604         @Test
605         public void testCreateComponentInstanceOnGraph() throws Exception {
606         ComponentInstanceBusinessLogic testSubject;
607         Component containerComponent = createResource();
608         Component originComponent = null;
609         ComponentInstance componentInstance = createInstances();
610         Either<ComponentInstance,ResponseFormat> result;
611         
612         Either<ImmutablePair<Component, String>, StorageOperationStatus> result2 = Either.right(StorageOperationStatus.ARTIFACT_NOT_FOUND);
613         when(toscaOperationFacade.addComponentInstanceToTopologyTemplate(containerComponent, containerComponent,componentInstance, false, user)).thenReturn(result2);
614         
615         // default test
616         testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "createComponentInstanceOnGraph", new Object[]{containerComponent, containerComponent, componentInstance, user});
617         }
618         
619         /*@Test
620         public void testCreateComponentInstanceOnGraph2() throws Exception {
621         ComponentInstanceBusinessLogic testSubject;
622         Component containerComponent = createResource();
623         containerComponent.setName("name");
624         ComponentInstance componentInstance = createInstances();
625         Either<ComponentInstance,ResponseFormat> result;
626         ImmutablePair<Component, String> pair =  new ImmutablePair<>(containerComponent,"");
627         
628         
629         
630         
631         Either<ImmutablePair<Component, String>, StorageOperationStatus> result2 = Either.left(pair);
632         when(toscaOperationFacade.addComponentInstanceToTopologyTemplate(containerComponent, containerComponent,componentInstance, false, user)).thenReturn(result2);
633         
634         // default test
635         testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "createComponentInstanceOnGraph", new Object[]{containerComponent, containerComponent, componentInstance, user});
636         }*/
637         
638         @Test
639         public void testUpdateComponentInstanceMetadata() throws Exception {
640         ComponentInstanceBusinessLogic testSubject;
641         String containerComponentParam = "";
642         String containerComponentId = "";
643         String componentInstanceId = "";
644         String userId = user.getUserId();
645         ComponentInstance componentInstance = createInstances();
646         Either<ComponentInstance,ResponseFormat> result;
647         
648         // default test
649         testSubject=createTestSubject();result=testSubject.updateComponentInstanceMetadata(containerComponentParam, containerComponentId, componentInstanceId, userId, componentInstance);
650         }
651
652         
653         @Test
654         public void testUpdateComponentInstanceMetadata_1() throws Exception {
655         ComponentInstanceBusinessLogic testSubject;String containerComponentParam = "";
656         String containerComponentId = "";
657         String componentInstanceId = "";
658         String userId = user.getUserId();
659         ComponentInstance componentInstance = createInstances();
660         boolean inTransaction = false;
661         boolean needLock = false;
662         boolean createNewTransaction = false;
663         Either<ComponentInstance,ResponseFormat> result;
664         
665         // default test
666         testSubject=createTestSubject();result=testSubject.updateComponentInstanceMetadata(containerComponentParam, containerComponentId, componentInstanceId, userId, componentInstance, inTransaction, needLock, createNewTransaction);
667         }
668
669         
670
671
672         
673         @Test
674         public void testValidateParent() throws Exception {
675         ComponentInstanceBusinessLogic testSubject;
676         Component containerComponent = createResource();
677         String nodeTemplateId = "";
678         boolean result;
679         
680         // default test
681         testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "validateParent", new Object[]{containerComponent, nodeTemplateId});
682         }
683
684         
685         @Test
686         public void testGetComponentType() throws Exception {
687         ComponentInstanceBusinessLogic testSubject;
688         ComponentTypeEnum containerComponentType = ComponentTypeEnum.RESOURCE;
689         ComponentTypeEnum result;
690         
691         // default test
692         testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "getComponentType", new Object[]{ComponentTypeEnum.class});
693         }
694
695         
696         
697         @Test
698         public void testGetNewGroupName() throws Exception {
699         ComponentInstanceBusinessLogic testSubject;String oldPrefix = "";
700         String newNormailzedPrefix = "";
701         String qualifiedGroupInstanceName = "";
702         String result;
703         
704         // test 1
705         testSubject=createTestSubject();
706         result=Deencapsulation.invoke(testSubject, "getNewGroupName", new Object[]{oldPrefix, newNormailzedPrefix, qualifiedGroupInstanceName});
707         }
708
709         
710         @Test
711         public void testUpdateComponentInstanceMetadata_3() throws Exception {
712         ComponentInstanceBusinessLogic testSubject;
713         ComponentInstance oldComponentInstance = createInstances();
714         ComponentInstance newComponentInstance = null;
715         ComponentInstance result;
716         
717         // default test
718         testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "updateComponentInstanceMetadata", new Object[]{oldComponentInstance, oldComponentInstance});
719         }
720
721         
722         @Test
723         public void testDeleteComponentInstance() throws Exception {
724         ComponentInstanceBusinessLogic testSubject;String containerComponentParam = "";
725         String containerComponentId = "";
726         String componentInstanceId = "";
727         String userId = user.getUserId();
728         Either<ComponentInstance,ResponseFormat> result;
729         
730         // default test
731         testSubject=createTestSubject();result=testSubject.deleteComponentInstance(containerComponentParam, containerComponentId, componentInstanceId, userId);
732         }
733
734         
735         @Test
736         public void testDeleteForwardingPaths() throws Exception {
737         ComponentInstanceBusinessLogic testSubject;
738         Component service = createService();
739         String serviceId = service.getUniqueId();
740         List<String> pathIdsToDelete = new ArrayList<>();
741         Either<Set<String>,ResponseFormat> result;
742         
743 //      Either<Service, StorageOperationStatus> storageStatus = toscaOperationFacade.getToscaElement(serviceId);
744         when(toscaOperationFacade.getToscaElement(serviceId)).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
745         
746         // default test
747         testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "deleteForwardingPaths", new Object[]{serviceId, pathIdsToDelete});
748         }
749
750         
751         @Test
752         public void testAssociateRIToRIOnGraph() throws Exception {
753         ComponentInstanceBusinessLogic testSubject;
754         Component containerComponent = createResource();
755         RequirementCapabilityRelDef requirementDef = new RequirementCapabilityRelDef();
756         ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
757         boolean inTransaction = false;
758         Either<RequirementCapabilityRelDef,ResponseFormat> result;
759         
760         
761
762         Either<RequirementCapabilityRelDef, StorageOperationStatus> getResourceResult = Either.left(requirementDef);
763         when(toscaOperationFacade.associateResourceInstances(containerComponent.getUniqueId(), requirementDef)).thenReturn(getResourceResult);
764         
765         // default test
766         testSubject=createTestSubject();result=testSubject.associateRIToRIOnGraph(containerComponent, requirementDef, componentTypeEnum, inTransaction);
767         }
768
769
770         
771         @Test
772         public void testFindRelation() throws Exception {
773         ComponentInstanceBusinessLogic testSubject;
774         String relationId = "";
775         List<RequirementCapabilityRelDef> requirementCapabilityRelations = new ArrayList<>();
776         RequirementCapabilityRelDef result;
777         
778         // default test
779         testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "findRelation", new Object[]{relationId, requirementCapabilityRelations});
780         }
781
782                 
783         @Test
784         public void testIsNetworkRoleServiceProperty() throws Exception {
785         ComponentInstanceBusinessLogic testSubject;
786         ComponentInstanceProperty property = new ComponentInstanceProperty();
787         ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
788         boolean result;
789         
790         // default test
791         testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "isNetworkRoleServiceProperty", new Object[]{property, componentTypeEnum});
792         }
793
794         
795         @Test
796         public void testConcatServiceNameToVLINetworkRolePropertiesValues() throws Exception {
797         ComponentInstanceBusinessLogic testSubject;
798         ToscaOperationFacade toscaOperationFacade = new ToscaOperationFacade();
799         ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
800         String componentId = "";
801         String resourceInstanceId = "";
802         List<ComponentInstanceProperty> properties = new ArrayList<>();
803         StorageOperationStatus result;
804         
805         // default test
806         testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "concatServiceNameToVLINetworkRolePropertiesValues", new Object[]{toscaOperationFacade, componentTypeEnum, componentId, resourceInstanceId, properties});
807         }
808
809         
810         @Test
811         public void testCreateOrUpdatePropertiesValues() throws Exception {
812         ComponentInstanceBusinessLogic testSubject;
813         ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
814         Component component = createResource();
815         String componentId = component.getUniqueId();
816         String resourceInstanceId = "";
817         List<ComponentInstanceProperty> properties = new ArrayList<>();
818         String userId = user.getUserId();
819         Either<List<ComponentInstanceProperty>,ResponseFormat> result;
820         
821 //      Either<Component, StorageOperationStatus> getResourceResult = toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll);
822         when(toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(component));
823         
824         // test 1
825         testSubject=createTestSubject();
826         result=testSubject.createOrUpdatePropertiesValues(componentTypeEnum, componentId, resourceInstanceId, properties, userId);
827         
828         componentTypeEnum =null;
829         result=testSubject.createOrUpdatePropertiesValues(componentTypeEnum, componentId, resourceInstanceId, properties, userId);
830         
831         when(toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll)).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
832         result=testSubject.createOrUpdatePropertiesValues(componentTypeEnum, componentId, resourceInstanceId, properties, userId);
833         
834         }
835
836         
837         @Test
838         public void testUpdateCapabilityPropertyOnContainerComponent() throws Exception {
839         ComponentInstanceBusinessLogic testSubject;
840         ComponentInstanceProperty property = new ComponentInstanceProperty();
841         String newValue = "";
842         Component containerComponent = createResource();
843         ComponentInstance foundResourceInstance = createInstances();
844         String capabilityType = "";
845         String capabilityName = "";
846         ResponseFormat result;
847         
848         // default test
849         testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "updateCapabilityPropertyOnContainerComponent", new Object[]{property, newValue, containerComponent, foundResourceInstance, capabilityType, capabilityName});
850         }
851
852         
853         
854         @Test
855         public void testCreateOrUpdateInstanceInputValues() throws Exception {
856         ComponentInstanceBusinessLogic testSubject;
857         ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
858         Component resource = createResource();
859         String componentId = resource.getUniqueId();
860         String resourceInstanceId = "";
861         List<ComponentInstanceInput> inputs = new ArrayList<>();
862         String userId = user.getUserId();
863         Either<List<ComponentInstanceInput>,ResponseFormat> result;
864         
865          when(toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll)).thenReturn(Either.left(resource));
866         
867         // test 1
868         testSubject=createTestSubject();
869         result=testSubject.createOrUpdateInstanceInputValues(componentTypeEnum, componentId, resourceInstanceId, inputs, userId);
870         componentTypeEnum =null;
871         result=testSubject.createOrUpdateInstanceInputValues(componentTypeEnum, componentId, resourceInstanceId, inputs, userId);
872         
873         
874          when(toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseAll)).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
875          result=testSubject.createOrUpdateInstanceInputValues(componentTypeEnum, componentId, resourceInstanceId, inputs, userId);
876         
877         }
878
879         
880         @Test
881         public void testCreateOrUpdateGroupInstancePropertyValue() throws Exception {
882         ComponentInstanceBusinessLogic testSubject;
883         ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
884         Component resource = createResource();
885         String componentId = resource.getUniqueId();
886         String resourceInstanceId = "";
887         String groupInstanceId = "";
888         ComponentInstanceProperty property = new ComponentInstanceProperty();
889         String userId = user.getUserId();
890         Either<ComponentInstanceProperty,ResponseFormat> result;
891         
892         
893          when(toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(resource));
894         
895         // test 1
896         testSubject=createTestSubject();
897         result=testSubject.createOrUpdateGroupInstancePropertyValue(componentTypeEnum, componentId, resourceInstanceId, groupInstanceId, property, userId);
898         componentTypeEnum = null;
899         result=testSubject.createOrUpdateGroupInstancePropertyValue(componentTypeEnum, componentId, resourceInstanceId, groupInstanceId, property, userId);
900         
901          when(toscaOperationFacade.getToscaElement(componentId, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
902          result=testSubject.createOrUpdateGroupInstancePropertyValue(componentTypeEnum, componentId, resourceInstanceId, groupInstanceId, property, userId);
903         }
904
905         
906         @Test
907         public void testCreateOrUpdateInputValue() throws Exception {
908         ComponentInstanceBusinessLogic testSubject;
909         Component component = createResource();
910         ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
911         String componentId = component.getUniqueId();
912         String resourceInstanceId = component.getUniqueId();
913         ComponentInstanceInput inputProperty = new ComponentInstanceInput();
914         String userId = user.getUserId();
915         Either<ComponentInstanceInput,ResponseFormat> result;
916         
917
918         Either<Component, StorageOperationStatus> getResourceResult = Either.left(component);
919         when(toscaOperationFacade.getToscaElement(component.getUniqueId(), JsonParseFlagEnum.ParseMetadata)).thenReturn(getResourceResult);
920         
921         // test 1
922         testSubject=createTestSubject();
923         result=testSubject.createOrUpdateInputValue(componentTypeEnum, componentId, resourceInstanceId, inputProperty, userId);
924         
925         componentTypeEnum = null;
926         result=testSubject.createOrUpdateInputValue(componentTypeEnum, componentId, resourceInstanceId, inputProperty, userId);
927         
928         when(toscaOperationFacade.getToscaElement(component.getUniqueId(), JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
929         result=testSubject.createOrUpdateInputValue(componentTypeEnum, componentId, resourceInstanceId, inputProperty, userId);                 
930         }
931
932         
933         @Test
934         public void testDeletePropertyValue() throws Exception {
935         ComponentInstanceBusinessLogic testSubject;
936         ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
937         Component service = createService();
938         String serviceId = service.getUniqueId();
939         String resourceInstanceId = "";
940         String propertyValueId = "";
941         String userId = user.getUserId();
942         Either<ComponentInstanceProperty,ResponseFormat> result;
943         
944          when(toscaOperationFacade.getToscaElement(serviceId, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.left(service));
945         
946         // test 1
947         testSubject=createTestSubject();
948         result=testSubject.deletePropertyValue(componentTypeEnum, serviceId, resourceInstanceId, propertyValueId, userId);
949         componentTypeEnum= null;
950         result=testSubject.deletePropertyValue(componentTypeEnum, serviceId, resourceInstanceId, propertyValueId, userId);
951         
952          when(toscaOperationFacade.getToscaElement(serviceId, JsonParseFlagEnum.ParseMetadata)).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
953         result=testSubject.deletePropertyValue(componentTypeEnum, serviceId, resourceInstanceId, propertyValueId, userId);
954         }
955
956         
957         @Test
958         public void testGetAndValidateOriginComponentOfComponentInstance() throws Exception {
959         ComponentInstanceBusinessLogic testSubject;
960         ComponentTypeEnum containerComponentType = ComponentTypeEnum.RESOURCE;
961         Component resource = createResource();
962         ComponentInstance componentInstance = createInstances();
963         Either<Component,ResponseFormat> result;
964         
965          when(toscaOperationFacade.getToscaFullElement(componentInstance.getComponentUid())).thenReturn(Either.left(resource));
966         
967         // default test
968         testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "getAndValidateOriginComponentOfComponentInstance", new Object[]{containerComponentType, componentInstance});
969         }
970
971         
972
973
974         
975         @Test
976         public void testGetComponentParametersViewForForwardingPath() throws Exception {
977         ComponentInstanceBusinessLogic testSubject;
978         ComponentParametersView result;
979         
980         // default test
981         testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "getComponentParametersViewForForwardingPath");
982         }
983
984         
985         @Test
986         public void testChangeComponentInstanceVersion() throws Exception {
987         ComponentInstanceBusinessLogic testSubject;
988         String containerComponentParam = "";
989         String containerComponentId = "";
990         String componentInstanceId = "";
991         String userId = user.getUserId();
992         ComponentInstance newComponentInstance = createInstances();
993         Either<ComponentInstance,ResponseFormat> result;
994         
995         // default test
996         testSubject=createTestSubject();result=testSubject.changeComponentInstanceVersion(containerComponentParam, containerComponentId, componentInstanceId, userId, newComponentInstance);
997         newComponentInstance = null;
998         testSubject=createTestSubject();result=testSubject.changeComponentInstanceVersion(containerComponentParam, containerComponentId, componentInstanceId, userId, newComponentInstance);
999         
1000         }
1001         
1002         @Test
1003         public void testValidateInstanceNameUniquenessUponUpdate() throws Exception {
1004         ComponentInstanceBusinessLogic testSubject;
1005         Component containerComponent = createResource();
1006         ComponentInstance oldComponentInstance = createInstances();
1007         String newInstanceName = oldComponentInstance.getName();
1008         Boolean result;
1009         
1010         // default test
1011         testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "validateInstanceNameUniquenessUponUpdate", new Object[]{containerComponent, oldComponentInstance, newInstanceName});
1012         }
1013
1014         
1015         @Test
1016         public void testGetResourceInstanceById() throws Exception {
1017         ComponentInstanceBusinessLogic testSubject;
1018         Component containerComponent = createResource();
1019         String instanceId = "";
1020         Either<ComponentInstance,StorageOperationStatus> result;
1021         
1022         // default test
1023         testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "getResourceInstanceById", new Object[]{containerComponent, instanceId});
1024         }
1025
1026         
1027         @Test
1028         public void testBuildComponentInstance() throws Exception {
1029         ComponentInstanceBusinessLogic testSubject;
1030         ComponentInstance resourceInstanceForUpdate = createInstances();
1031         ComponentInstance origInstanceForUpdate = null;
1032         ComponentInstance result;
1033         
1034         // default test
1035         testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "buildComponentInstance", new Object[]{resourceInstanceForUpdate, resourceInstanceForUpdate});
1036         }
1037
1038         
1039
1040
1041         
1042         @Test
1043         public void testFindCapabilityOfInstance() throws Exception {
1044         ComponentInstanceBusinessLogic testSubject;String componentId = "";
1045         String instanceId = "";
1046         String capabilityType = "";
1047         String capabilityName = "";
1048         String ownerId = "";
1049         Map<String,List<CapabilityDefinition>> instanceCapabilities = new HashMap<>();
1050         Either<List<ComponentInstanceProperty>,ResponseFormat> result;
1051         
1052         // default test
1053         testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "findCapabilityOfInstance", new Object[]{componentId, instanceId, capabilityType, capabilityName, ownerId, instanceCapabilities});
1054         }
1055
1056         
1057         @Test
1058         public void testFetchComponentInstanceCapabilityProperties() throws Exception {
1059         ComponentInstanceBusinessLogic testSubject;String componentId = "";
1060         String instanceId = "";
1061         String capabilityType = "";
1062         String capabilityName = "";
1063         String ownerId = "";
1064         Either<List<ComponentInstanceProperty>,ResponseFormat> result;
1065         
1066         // default test
1067         testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "fetchComponentInstanceCapabilityProperties", new Object[]{componentId, instanceId, capabilityType, capabilityName, ownerId});
1068         }
1069
1070         
1071         @Test
1072         public void testUpdateCapabilityPropertyOnContainerComponent_1() throws Exception {
1073         ComponentInstanceBusinessLogic testSubject;
1074         ComponentInstanceProperty property = new ComponentInstanceProperty();
1075         String newValue = "";
1076         Component containerComponent = createResource();
1077         ComponentInstance foundResourceInstance = createInstances();
1078         String capabilityType = "";
1079         String capabilityName = "";
1080         String ownerId = "";
1081         ResponseFormat result;
1082         
1083         // default test
1084         testSubject=createTestSubject();result=Deencapsulation.invoke(testSubject, "updateCapabilityPropertyOnContainerComponent", new Object[]{property, newValue, containerComponent, foundResourceInstance, capabilityType, capabilityName, ownerId});
1085         }
1086
1087         
1088         @Test
1089         public void testUpdateInstanceCapabilityProperties() throws Exception {
1090         ComponentInstanceBusinessLogic testSubject;
1091         ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
1092         Component resource = createResource();
1093         String containerComponentId = resource.getUniqueId();
1094         String componentInstanceUniqueId = "";
1095         String capabilityType = "";
1096         String capabilityName = "";
1097         String ownerId = "";
1098         List<ComponentInstanceProperty> properties = new ArrayList<>();
1099         String userId = user.getUserId();
1100         Either<List<ComponentInstanceProperty>,ResponseFormat> result;
1101         
1102         
1103          when(toscaOperationFacade.getToscaFullElement(containerComponentId)).thenReturn(Either.left(resource));
1104         
1105         
1106         
1107         // test 1
1108         testSubject=createTestSubject();
1109         result=testSubject.updateInstanceCapabilityProperties(componentTypeEnum, containerComponentId, componentInstanceUniqueId, capabilityType, capabilityName, ownerId, properties, userId);
1110         when(toscaOperationFacade.getToscaFullElement(containerComponentId)).thenReturn(Either.right(StorageOperationStatus.ARTIFACT_NOT_FOUND));
1111         result=testSubject.updateInstanceCapabilityProperties(componentTypeEnum, containerComponentId, componentInstanceUniqueId, capabilityType, capabilityName, ownerId, properties, userId);
1112         componentTypeEnum = null;
1113         result=testSubject.updateInstanceCapabilityProperties(componentTypeEnum, containerComponentId, componentInstanceUniqueId, capabilityType, capabilityName, ownerId, properties, userId);
1114         
1115         
1116         }
1117
1118         
1119         @Test
1120         public void testUpdateInstanceCapabilityProperties_1() throws Exception {
1121         ComponentInstanceBusinessLogic testSubject;
1122         ComponentTypeEnum componentTypeEnum = ComponentTypeEnum.RESOURCE;
1123         Component component = createResource();
1124         String containerComponentId = component.getUniqueId();
1125         String componentInstanceUniqueId = "";
1126         String capabilityType = "";
1127         String capabilityName = "";
1128         List<ComponentInstanceProperty> properties = new ArrayList<>();
1129         String userId = user.getUserId();
1130         Either<List<ComponentInstanceProperty>,ResponseFormat> result;
1131         
1132          
1133          when(toscaOperationFacade.getToscaFullElement(containerComponentId)).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1134         // test 1
1135         testSubject=createTestSubject();
1136         result=testSubject.updateInstanceCapabilityProperties(componentTypeEnum, containerComponentId, componentInstanceUniqueId, capabilityType, capabilityName, properties, userId);
1137          when(toscaOperationFacade.getToscaFullElement(containerComponentId)).thenReturn(Either.left(component));
1138          result=testSubject.updateInstanceCapabilityProperties(componentTypeEnum, containerComponentId, componentInstanceUniqueId, capabilityType, capabilityName, properties, userId);
1139         }
1140
1141
1142 }
1143
1144         
1145
SDC Parent Project Catalog FE and BE