2 * Copyright © 2016-2018 European Support Limited
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 * ================================================================================
16 * Modifications copyright (c) 2019 Nokia
17 * ================================================================================
20 package org.openecomp.sdc.be.components.impl;
22 import fj.data.Either;
23 import org.junit.Assert;
24 import org.junit.Before;
25 import org.junit.Test;
26 import org.mockito.Mockito;
27 import org.mockito.MockitoAnnotations;
28 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
29 import org.openecomp.sdc.be.components.validation.CapabilitiesValidation;
30 import org.openecomp.sdc.be.components.validation.UserValidations;
31 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
32 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
33 import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
34 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
35 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
36 import org.openecomp.sdc.be.impl.ComponentsUtils;
37 import org.openecomp.sdc.be.model.CapabilityDefinition;
38 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
39 import org.openecomp.sdc.be.model.Component;
40 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
41 import org.openecomp.sdc.be.model.ComponentParametersView;
42 import org.openecomp.sdc.be.model.LifecycleStateEnum;
43 import org.openecomp.sdc.be.model.RelationshipInfo;
44 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
45 import org.openecomp.sdc.be.model.Resource;
46 import org.openecomp.sdc.be.model.Service;
47 import org.openecomp.sdc.be.model.User;
48 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.CapabilitiesOperation;
49 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
50 import org.openecomp.sdc.be.model.operations.api.ICapabilityTypeOperation;
51 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
52 import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation;
53 import org.openecomp.sdc.be.user.Role;
54 import org.openecomp.sdc.be.user.UserBusinessLogic;
55 import org.openecomp.sdc.common.impl.ExternalConfiguration;
56 import org.openecomp.sdc.exception.ResponseFormat;
58 import java.util.ArrayList;
59 import java.util.Collections;
60 import java.util.HashMap;
61 import java.util.List;
63 import java.util.stream.Collectors;
64 import java.util.stream.Stream;
66 import static org.mockito.ArgumentMatchers.any;
67 import static org.mockito.ArgumentMatchers.anyBoolean;
68 import static org.mockito.ArgumentMatchers.anyCollection;
69 import static org.mockito.ArgumentMatchers.anyObject;
70 import static org.mockito.ArgumentMatchers.anyString;
71 import static org.mockito.ArgumentMatchers.eq;
72 import static org.mockito.Mockito.when;
74 public class CapabilitiesBusinessLogicTest extends BaseBusinessLogicMock {
75 private final String componentId = "resourceId1";
76 private final String capabilityId = "uniqueId1";
78 private final JanusGraphDao mockJanusGraphDao = Mockito.mock(JanusGraphDao.class);
79 private final UserBusinessLogic mockUserAdmin = Mockito.mock(UserBusinessLogic.class);
80 private final ToscaOperationFacade toscaOperationFacade = Mockito.mock(ToscaOperationFacade.class);
81 private final UserValidations userValidations = Mockito.mock(UserValidations.class);
82 private final CapabilitiesOperation capabilitiesOperation = Mockito.mock(CapabilitiesOperation.class);
83 private final CapabilitiesValidation capabilitiesValidation = Mockito.mock(CapabilitiesValidation.class);
85 private final GraphLockOperation graphLockOperation = Mockito.mock(GraphLockOperation.class);
86 private User user = null;
88 private final ICapabilityTypeOperation capabilityTypeOperation = Mockito.mock(ICapabilityTypeOperation.class);
90 private CapabilitiesBusinessLogic capabilitiesBusinessLogicMock = new CapabilitiesBusinessLogic(elementDao, groupOperation, groupInstanceOperation,
91 groupTypeOperation, groupBusinessLogic, interfaceOperation, interfaceLifecycleTypeOperation, capabilityTypeOperation, artifactToscaOperation);
95 MockitoAnnotations.openMocks(this);
96 ExternalConfiguration.setAppName("catalog-be");
98 ComponentsUtils componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class));
100 // User data and management
102 user.setUserId("jh0003");
103 user.setFirstName("Jimmi");
104 user.setLastName("Hendrix");
105 user.setRole(Role.ADMIN.name());
107 when(mockUserAdmin.getUser("jh0003", false)).thenReturn(user);
108 when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Resource)))
109 .thenReturn(StorageOperationStatus.OK);
111 //CapabilityOperation
112 when(capabilitiesValidation.validateCapabilities(anyCollection(), anyObject(), anyBoolean()))
113 .thenReturn(Either.left(true));
114 when(capabilitiesOperation.addCapabilities(anyString(), anyObject()))
115 .thenReturn(Either.left(createMockCapabilityListToReturn(
116 createCapability("capName", "capDesc", "capType", "source1",
119 when(capabilitiesOperation.updateCapabilities(anyString(), anyObject()))
120 .thenReturn(Either.left(createMockCapabilityListToReturn(
121 createCapability("capName", "capDesc", "capType", "source1",
123 when(capabilitiesOperation.deleteCapabilities( anyObject(), anyString()))
124 .thenReturn(StorageOperationStatus.OK);
125 when(mockJanusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK);
127 capabilitiesBusinessLogicMock = new CapabilitiesBusinessLogic(elementDao, groupOperation, groupInstanceOperation,
128 groupTypeOperation, groupBusinessLogic, interfaceOperation, interfaceLifecycleTypeOperation,
129 capabilityTypeOperation, artifactToscaOperation);
130 capabilitiesBusinessLogicMock.setComponentsUtils(componentsUtils);
131 capabilitiesBusinessLogicMock.setUserAdmin(mockUserAdmin);
132 capabilitiesBusinessLogicMock.setGraphLockOperation(graphLockOperation);
133 capabilitiesBusinessLogicMock.setJanusGraphDao(mockJanusGraphDao);
134 capabilitiesBusinessLogicMock.setToscaOperationFacade(toscaOperationFacade);
135 capabilitiesBusinessLogicMock.setUserValidations(userValidations);
136 capabilitiesBusinessLogicMock.setCapabilitiesOperation(capabilitiesOperation);
137 capabilitiesBusinessLogicMock.setCapabilitiesValidation(capabilitiesValidation);
141 public void shouldPassCreateCapabilitiesFirstTimeInComponentForHappyScenario(){
142 List<CapabilityDefinition> capabilityDefinitions = createMockCapabilityListToReturn(
143 createCapability("capName", "capDesc", "capType", "source1",
145 Resource resource = createComponent(false);
146 resource.setComponentType(ComponentTypeEnum.RESOURCE);
147 validateUserRoles(Role.ADMIN, Role.DESIGNER);
148 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
149 .thenReturn(Either.left(resource));
150 Either<List<CapabilityDefinition>, ResponseFormat> capabilities = capabilitiesBusinessLogicMock
151 .createCapabilities(componentId, capabilityDefinitions, user,
152 "createCapabilities", true);
153 Assert.assertTrue(capabilities.isLeft());
154 Assert.assertTrue(capabilities.left().value().stream().anyMatch(capabilityDefinition ->
155 capabilityDefinition.getName().equals("capName")));
159 public void shouldPassCreateCapabilitiesForHappyScenario(){
160 List<CapabilityDefinition> capabilityDefinitions = createMockCapabilityListToReturn(
161 createCapability("capName2", "capDesc", "capType", "source1",
163 Resource resource = createComponent(true);
164 resource.setComponentType(ComponentTypeEnum.RESOURCE);
165 validateUserRoles(Role.ADMIN, Role.DESIGNER);
166 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
167 .thenReturn(Either.left(resource));
168 Either<List<CapabilityDefinition>, ResponseFormat> capabilities = capabilitiesBusinessLogicMock
169 .createCapabilities(componentId, capabilityDefinitions, user,
170 "createCapabilities", false);
172 Assert.assertTrue(capabilities.isLeft());
173 Assert.assertTrue(capabilities.left().value().stream().anyMatch(capabilityDefinition ->
174 capabilityDefinition.getName().equals("capName2")));
178 public void shouldFailCreateCapabilitiesWhenOperationFailedInJanusGraph(){
179 List<CapabilityDefinition> capabilityDefinitions = createMockCapabilityListToReturn(
180 createCapability("capName2", "capDesc", "capType", "source1",
182 Resource resource = createComponent(true);
183 resource.setComponentType(ComponentTypeEnum.RESOURCE);
184 validateUserRoles(Role.ADMIN, Role.DESIGNER);
185 when(capabilitiesOperation.addCapabilities(anyString(), anyObject()))
186 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
187 when(capabilitiesOperation.updateCapabilities(anyString(), anyObject()))
188 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
189 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
190 .thenReturn(Either.left(resource));
191 Either<List<CapabilityDefinition>, ResponseFormat> capabilities = capabilitiesBusinessLogicMock
192 .createCapabilities(componentId, capabilityDefinitions, user,
193 "createCapabilities", true);
195 Assert.assertTrue(capabilities.isRight());
198 public void shouldPassUpdateCapabilitiesForHappyScenario(){
200 List<CapabilityDefinition> capabilityDefinitions = createMockCapabilityListToReturn(
201 createCapability("capName", "capDesc updated", "capType", "source1",
203 Resource resource = createComponent(true);
204 resource.setComponentType(ComponentTypeEnum.RESOURCE);
205 validateUserRoles(Role.ADMIN, Role.DESIGNER);
206 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
207 .thenReturn(Either.left(resource));
208 when(toscaOperationFacade.getParentComponents(anyString()))
209 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
210 Either<List<CapabilityDefinition>, ResponseFormat> capabilities = capabilitiesBusinessLogicMock
211 .updateCapabilities(componentId, capabilityDefinitions, user
212 , "updateCapabilities", true);
213 Assert.assertTrue(capabilities.isLeft());
214 Assert.assertTrue(capabilities.left().value().stream().anyMatch(capabilityDefinition ->
215 capabilityDefinition.getMaxOccurrences().equals("11")));
219 public void shouldPassUpdateCapabilityTypeUpdateWhenTypeIsNotAvailable(){
221 List<CapabilityDefinition> capabilityDefinitions = createMockCapabilityListToReturn(
222 createCapability("capName", "capDesc updated", "capTypeUpdate", "source1",
224 Resource resource = createComponent(true);
225 resource.setComponentType(ComponentTypeEnum.RESOURCE);
226 validateUserRoles(Role.ADMIN, Role.DESIGNER);
227 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
228 .thenReturn(Either.left(resource));
229 when(toscaOperationFacade.getParentComponents(anyString()))
230 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
231 when((capabilitiesOperation.deleteCapabilityProperties(any(Component.class), anyString())))
232 .thenReturn(StorageOperationStatus.OK);
233 Either<List<CapabilityDefinition>, ResponseFormat> capabilities = capabilitiesBusinessLogicMock
234 .updateCapabilities(componentId, capabilityDefinitions, user,
235 "updateCapabilities",true);
236 Assert.assertTrue(capabilities.isLeft());
237 Assert.assertTrue(capabilities.left().value().stream().anyMatch(capabilityDefinition ->
238 capabilityDefinition.getMaxOccurrences().equals("11")));
242 public void shouldPassUpdateCapabilityTypeUpdateWhenTypeIsAvailable(){
244 List<CapabilityDefinition> capabilityDefinitions = createMockCapabilityListToReturn(
245 createCapability("capName", "capDesc updated", "capTypeUpdate1", "source1",
247 Resource resource = createComponent(true);
248 resource.setComponentType(ComponentTypeEnum.RESOURCE);
250 CapabilityDefinition capability = createCapability("capName", "capDesc", "capTypeUpdate1",
251 "source1", "0", "10");
252 capability.setUniqueId("unique2");
253 List<CapabilityDefinition> capabilityDefinitions1 = createMockCapabilityListToReturn(capability);
254 Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
255 capabilityMap.put("capTypeUpdate1", capabilityDefinitions1);
256 resource.getCapabilities().putAll(capabilityMap);
258 validateUserRoles(Role.ADMIN, Role.DESIGNER);
259 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
260 .thenReturn(Either.left(resource));
261 when(toscaOperationFacade.getParentComponents(anyString()))
262 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
263 when((capabilitiesOperation.deleteCapabilityProperties(any(Component.class), anyString())))
264 .thenReturn(StorageOperationStatus.OK);
265 Either<List<CapabilityDefinition>, ResponseFormat> capabilities = capabilitiesBusinessLogicMock
266 .updateCapabilities(componentId, capabilityDefinitions, user,
267 "updateCapabilities",true);
268 Assert.assertTrue(capabilities.isLeft());
269 Assert.assertTrue(capabilities.left().value().stream().anyMatch(capabilityDefinition ->
270 capabilityDefinition.getMaxOccurrences().equals("11")));
274 public void shouldFailUpdateCapabilitiesWhenOperationFailedInJanusGraph(){
275 List<CapabilityDefinition> capabilityDefinitions = createMockCapabilityListToReturn(
276 createCapability("capName2", "capDesc", "capType", "source1",
278 Resource resource = createComponent(true);
279 resource.setComponentType(ComponentTypeEnum.RESOURCE);
280 validateUserRoles(Role.ADMIN, Role.DESIGNER);
281 when(capabilitiesOperation.addCapabilities(anyString(), anyObject()))
282 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
283 when(capabilitiesOperation.updateCapabilities(anyString(), anyObject()))
284 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
285 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
286 .thenReturn(Either.left(resource));
287 Either<List<CapabilityDefinition>, ResponseFormat> capabilities = capabilitiesBusinessLogicMock
288 .updateCapabilities(componentId, capabilityDefinitions, user,
289 "updateCapabilities", true);
291 Assert.assertTrue(capabilities.isRight());
295 public void shouldPassDeleteCapabilitiesForHappyScenario(){
296 Resource resource = createComponent(true);
297 resource.setComponentType(ComponentTypeEnum.RESOURCE);
298 validateUserRoles(Role.ADMIN, Role.DESIGNER);
299 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
300 .thenReturn(Either.left(resource));
301 when(toscaOperationFacade.getParentComponents(anyString()))
302 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
303 when((capabilitiesOperation.deleteCapabilityProperties(any(Component.class), anyString())))
304 .thenReturn(StorageOperationStatus.OK);
305 Either<CapabilityDefinition, ResponseFormat> deleteCapabilityEither =
306 capabilitiesBusinessLogicMock.deleteCapability(componentId, capabilityId, user, true);
307 Assert.assertTrue(deleteCapabilityEither.isLeft());
312 public void shouldFailDeleteCapabilitiesWhenOperationFailedInJanusGraph(){
313 Resource resource = createComponent(true);
314 resource.setComponentType(ComponentTypeEnum.RESOURCE);
315 validateUserRoles(Role.ADMIN, Role.DESIGNER);
316 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
317 .thenReturn(Either.left(resource));
318 when(toscaOperationFacade.getParentComponents(anyString()))
319 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
320 when(capabilitiesOperation.deleteCapabilities(anyObject(), anyString()))
321 .thenReturn(StorageOperationStatus.GENERAL_ERROR);
322 Either<CapabilityDefinition, ResponseFormat> deleteCapabilityEither
323 = capabilitiesBusinessLogicMock.deleteCapability(componentId, capabilityId, user, true);
324 Assert.assertTrue(deleteCapabilityEither.isRight());
328 public void shouldFailDeleteCapabilitiesWhenCapabilityUsedInServiceComposition(){
329 Resource resource = createComponent(true);
330 resource.setComponentType(ComponentTypeEnum.RESOURCE);
331 validateUserRoles(Role.ADMIN, Role.DESIGNER);
332 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
333 .thenReturn(Either.left(resource));
334 when(toscaOperationFacade.getParentComponents(anyString()))
335 .thenReturn(Either.left(Collections.singletonList(createParentService())));
336 Either<CapabilityDefinition, ResponseFormat> deleteCapabilityEither
337 = capabilitiesBusinessLogicMock.deleteCapability(componentId, capabilityId, user, true);
338 Assert.assertTrue(deleteCapabilityEither.isRight());
342 public void shouldPassGetCapabilitiesForHappyScenario(){
343 Resource resource = createComponent(true);
344 resource.setComponentType(ComponentTypeEnum.RESOURCE);
345 validateUserRoles(Role.ADMIN, Role.DESIGNER);
346 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
347 .thenReturn(Either.left(resource));
348 when(toscaOperationFacade.getParentComponents(anyString()))
349 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
350 Either<CapabilityDefinition, ResponseFormat> getCapabilityEither
351 = capabilitiesBusinessLogicMock.getCapability(componentId, capabilityId, user, true);
352 Assert.assertTrue(getCapabilityEither.isLeft());
357 public void shouldFailGetCapabilitiesWhenCapabilityNotExist(){
358 Resource resource = createComponent(true);
359 resource.setComponentType(ComponentTypeEnum.RESOURCE);
360 validateUserRoles(Role.ADMIN, Role.DESIGNER);
361 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
362 .thenReturn(Either.left(resource));
363 when(toscaOperationFacade.getParentComponents(anyString()))
364 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
365 Either<CapabilityDefinition, ResponseFormat> getCapabilityEither
366 = capabilitiesBusinessLogicMock.getCapability(componentId, "capId1", user, true);
367 Assert.assertTrue(getCapabilityEither.isRight());
371 private ComponentInstanceProperty createCIP(String type, String name) {
372 ComponentInstanceProperty instanceProperty = new ComponentInstanceProperty();
373 instanceProperty.setType(type);
374 instanceProperty.setName(name);
375 instanceProperty.setDescription("prop_description");
376 instanceProperty.setParentUniqueId(capabilityId);
377 instanceProperty.setSchema(new SchemaDefinition());
378 return instanceProperty;
382 public void shouldPassCreateCapabilitiesWithPropertiesForHappyScenario(){
383 CapabilityDefinition capability = createCapability("capName", "capDesc", "capType", "source1",
385 capability.setProperties(Collections.singletonList(createCIP("name", "type")));
386 List<CapabilityDefinition> capabilityDefinitions = createMockCapabilityListToReturn(capability);
387 Resource resource = createComponent(false);
388 resource.setComponentType(ComponentTypeEnum.RESOURCE);
389 validateUserRoles(Role.ADMIN, Role.DESIGNER);
390 when(toscaOperationFacade.getToscaElement(anyString(), any(ComponentParametersView.class)))
391 .thenReturn(Either.left(resource));
392 when(capabilitiesOperation.createOrUpdateCapabilityProperties(anyString(), any())).thenReturn(StorageOperationStatus.OK);
393 Either<List<CapabilityDefinition>, ResponseFormat> capabilities = capabilitiesBusinessLogicMock
394 .createCapabilities(componentId, capabilityDefinitions, user,
395 "createCapabilities", true);
396 Assert.assertTrue(capabilities.isLeft());
397 Assert.assertTrue(capabilities.left().value().stream().anyMatch(capabilityDefinition ->
398 capabilityDefinition.getName().equals("capName")));
399 Assert.assertTrue(capabilities.left().value().stream().anyMatch(capabilityDefinition ->
400 capabilityDefinition.getProperties().size() == 1));
403 private Resource createComponent(boolean needCapability) {
404 Resource resource = new Resource();
405 resource.setName("Resource1");
406 resource.addCategory("Network Layer 2-3", "Router");
407 resource.setDescription("My short description");
408 List<String> tgs = new ArrayList<>();
410 tgs.add(resource.getName());
411 resource.setTags(tgs);
414 List<CapabilityDefinition> capabilityDefinitions = createMockCapabilityListToReturn(
415 createCapability("capName", "capDesc", "capType", "source1",
417 Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
418 capabilityMap.put("capType", capabilityDefinitions);
419 resource.setCapabilities(capabilityMap);
421 resource.setName(resource.getName());
422 resource.setVersion("0.1");
423 resource.setUniqueId(resource.getName().toLowerCase() + ":" + resource.getVersion());
424 resource.setCreatorUserId(user.getUserId());
425 resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
426 resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
430 private List<CapabilityDefinition> createMockCapabilityListToReturn(CapabilityDefinition capabilityDefinition) {
431 List<CapabilityDefinition> capabilityDefinitions = new ArrayList<>();
432 capabilityDefinitions.add(capabilityDefinition);
433 return capabilityDefinitions;
436 private void validateUserRoles(Role... roles) {
437 List<Role> listOfRoles = Stream.of(roles).collect(Collectors.toList());
440 private CapabilityDefinition createCapability(String name, String description, String type,
441 String validSourceTypes, String minOccurrences,
442 String maxOccurrences) {
443 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
444 capabilityDefinition.setName(name);
445 capabilityDefinition.setDescription(description);
446 capabilityDefinition.setType(type);
447 capabilityDefinition.setValidSourceTypes(Collections.singletonList(validSourceTypes));
448 capabilityDefinition.setMaxOccurrences(maxOccurrences);
449 capabilityDefinition.setMinOccurrences(minOccurrences);
450 capabilityDefinition.setUniqueId(capabilityId);
451 return capabilityDefinition;
454 private Service createParentService() {
455 Service service = new Service();
456 service.setUniqueId("serviceUniqueId");
458 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
459 RequirementCapabilityRelDef relationDef = new RequirementCapabilityRelDef();
460 relationDef.setFromNode("fromNode");
461 relationDef.setToNode("toNode");
463 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
464 CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship();
466 RelationshipInfo relation = new RelationshipInfo();
467 relation.setCapabilityUid(capabilityId);
468 relation.setRequirementUid("reqUniqueId1");
469 capabilityRequirementRelationship.setRelation(relation);
471 relationships.add(capabilityRequirementRelationship);
472 relationDef.setRelationships(relationships);
473 resourceInstancesRelations.add(relationDef);
475 service.setComponentInstancesRelations(resourceInstancesRelations);