2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
21 package org.openecomp.sdc.ci.tests.execute.resource;
23 import org.apache.http.client.ClientProtocolException;
24 import org.junit.rules.TestName;
25 import org.openecomp.sdc.be.dao.api.ActionStatus;
26 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
27 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
28 import org.openecomp.sdc.be.model.*;
29 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
30 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
31 import org.openecomp.sdc.ci.tests.datatypes.enums.LifeCycleStatesEnum;
32 import org.openecomp.sdc.ci.tests.datatypes.enums.NormativeTypesEnum;
33 import org.openecomp.sdc.ci.tests.datatypes.enums.ResourceCategoryEnum;
34 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
35 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
36 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
37 import org.openecomp.sdc.ci.tests.utils.rest.*;
38 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
39 import org.testng.annotations.BeforeMethod;
40 import org.testng.annotations.Test;
42 import java.io.IOException;
43 import java.util.ArrayList;
44 import java.util.Arrays;
45 import java.util.List;
48 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_SUCCESS;
49 import static org.testng.AssertJUnit.*;
51 public class ComponentRelationshipInVfTest extends ComponentBaseTest {
53 public ComponentRelationshipInVfTest() {
54 super(new TestName(), ComponentRelationshipInVfTest.class.getName());
57 private ResourceReqDetails resourceDetailsVF;
58 private User designerUser;
59 private User adminUser;
60 private User testerUser;
61 private ResourceReqDetails resourceDetailsReq;
62 private ResourceReqDetails resourceDetailsCap;
65 public void before() throws Exception {
66 designerUser = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
67 adminUser = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
68 testerUser = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
70 resourceDetailsVF = ElementFactory.getDefaultResourceByType("VF100", NormativeTypesEnum.ROOT,
71 ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, designerUser.getUserId(), ResourceTypeEnum.VF.toString());
72 createResource(resourceDetailsVF, designerUser);
74 resourceDetailsReq = ElementFactory.getDefaultResourceByType("SoftCompRouter",
75 NormativeTypesEnum.SOFTWARE_COMPONENT, ResourceCategoryEnum.NETWORK_L2_3_ROUTERS,
76 designerUser.getUserId(), ResourceTypeEnum.CP.toString()); // resourceType
79 resourceDetailsCap = ElementFactory.getDefaultResourceByType("MyCompute", NormativeTypesEnum.COMPUTE,
80 ResourceCategoryEnum.NETWORK_L2_3_ROUTERS, designerUser.getUserId(), ResourceTypeEnum.CP.toString()); // resourceType
86 private void createResource(ResourceReqDetails resourceDetails, User user) throws Exception, IOException {
87 RestResponse createResourceResponse = ResourceRestUtils.createResource(resourceDetails, user);
88 ResourceRestUtils.checkCreateResponse(createResourceResponse);
89 if (!resourceDetails.getResourceType().equals("VF"))
90 LifecycleRestUtils.changeResourceState(resourceDetails, user, "0.1", LifeCycleStatesEnum.CHECKIN);
93 private void createAtomicResource(ResourceReqDetails resourceDetails, User user) throws Exception {
94 createResource(resourceDetails, user);
97 private RequirementCapabilityRelDef setRelationshipBetweenInstances(ComponentInstance riReq,
98 ComponentInstance riCap, CapReqDef capReqDef) throws Exception {
100 String capbilityUid = capReqDef.getCapabilities().get("tosca.capabilities.Container").get(0).getUniqueId();
101 String requirementUid = capReqDef.getRequirements().get("tosca.capabilities.Container").get(0).getUniqueId();
103 RequirementCapabilityRelDef requirementDef = new RequirementCapabilityRelDef();
104 requirementDef.setFromNode(riReq.getUniqueId());
105 requirementDef.setToNode(riCap.getUniqueId());
107 RelationshipInfo pair = new RelationshipInfo();
108 pair.setRequirementOwnerId(riReq.getUniqueId());
109 pair.setCapabilityOwnerId(riCap.getUniqueId());
110 pair.setRequirement("host");
111 RelationshipImpl relationship = new RelationshipImpl();
112 relationship.setType("tosca.capabilities.Container");
113 pair.setRelationships(relationship);
114 pair.setCapabilityUid(capbilityUid);
115 pair.setRequirementUid(requirementUid);
116 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
117 CapabilityRequirementRelationship capReqRel = new CapabilityRequirementRelationship();
118 relationships.add(capReqRel);
119 capReqRel.setRelation(pair);
120 requirementDef.setRelationships(relationships);
121 return requirementDef;
124 private ComponentInstance createComponentInstance(ResourceReqDetails res) throws Exception {
125 return createComponentInstance(res, designerUser);
128 private ComponentInstance createComponentInstance(ResourceReqDetails res, User user, ResourceReqDetails vf)
130 RestResponse response = ResourceRestUtils.createResourceInstance(res, user, vf.getUniqueId());
131 ResourceRestUtils.checkCreateResponse(response);
132 ComponentInstance compInstance = ResponseParser.parseToObject(response.getResponse(), ComponentInstance.class);
136 private ComponentInstance createComponentInstance(ResourceReqDetails res, User user) throws Exception {
137 return createComponentInstance(res, user, resourceDetailsVF);
140 private void createTwoAtomicResourcesByType(String reqType, String capType, User user1, User user2)
142 resourceDetailsReq.setResourceType(reqType);
143 createAtomicResource(resourceDetailsReq, user1);
144 resourceDetailsCap.setResourceType(capType);
145 createAtomicResource(resourceDetailsCap, user2);
148 private void createTwoAtomicResourcesByType(String reqType, String capType) throws Exception {
149 createTwoAtomicResourcesByType(reqType, capType, designerUser, designerUser);
153 public void associateInVF() throws Exception {
155 createTwoAtomicResourcesByType(ResourceTypeEnum.VFC.toString(), ResourceTypeEnum.VFC.toString());
157 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
158 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
160 CapReqDef capReqDef = getResourceReqCap();
162 List<CapabilityDefinition> capList = capReqDef.getCapabilities().get("tosca.capabilities.Container");
163 List<RequirementDefinition> reqList = capReqDef.getRequirements().get("tosca.capabilities.Container");
165 RequirementCapabilityRelDef requirementDef = new RequirementCapabilityRelDef();
166 requirementDef.setFromNode(riReq.getUniqueId());
167 requirementDef.setToNode(riCap.getUniqueId());
169 RelationshipInfo pair = new RelationshipInfo();
170 pair.setRequirementOwnerId(riReq.getUniqueId());
171 pair.setCapabilityOwnerId(riCap.getUniqueId());
172 pair.setRequirement("host");
173 RelationshipImpl relationship = new RelationshipImpl();
174 relationship.setType("tosca.capabilities.Container");
175 pair.setRelationships(relationship);
176 pair.setCapabilityUid(capList.get(0).getUniqueId());
177 pair.setRequirementUid(reqList.get(0).getUniqueId());
178 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
179 CapabilityRequirementRelationship capReqRel = new CapabilityRequirementRelationship();
180 relationships.add(capReqRel);
181 capReqRel.setRelation(pair);
182 requirementDef.setRelationships(relationships);
184 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
185 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
186 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
188 RestResponse getResourceResponse = ComponentRestUtils.getComponentRequirmentsCapabilities(designerUser,
190 capReqDef = ResponseParser.parseToObject(getResourceResponse.getResponse(), CapReqDef.class);
192 List<RequirementDefinition> list = capReqDef.getRequirements().get("tosca.capabilities.Container");
193 assertEquals("Check requirement", null, list);
195 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef, designerUser,
196 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
197 assertEquals("Check response code ", STATUS_CODE_SUCCESS, dissociateInstances.getErrorCode().intValue());
199 getResourceResponse = ComponentRestUtils.getComponentRequirmentsCapabilities(designerUser, resourceDetailsVF);
200 capReqDef = ResponseParser.parseToObject(getResourceResponse.getResponse(), CapReqDef.class);
202 list = capReqDef.getRequirements().get("tosca.capabilities.Container");
203 assertEquals("Check requirement", 1, list.size());
206 //////////////////////////////// Q A //////////////////////////////
207 private boolean checkRealtionship(String fromNode, String toNode, String resourceUniqueId) throws Exception {
208 List<RequirementCapabilityRelDef> componentInstancesRelations = getComponentInstancesRelations(
210 RequirementCapabilityRelDef requirementCapabilityRelDef = componentInstancesRelations.get(0);
211 boolean fromNodeCheck = requirementCapabilityRelDef.getFromNode().equals(fromNode);
212 boolean toNodeCheck = requirementCapabilityRelDef.getToNode().equals(toNode);
214 return fromNodeCheck && toNodeCheck;
217 private List<RequirementCapabilityRelDef> getComponentInstancesRelations(String resourceUniqueId)
218 throws ClientProtocolException, IOException {
219 Resource resource = getVfAsResourceObject(resourceUniqueId);
220 List<RequirementCapabilityRelDef> componenRelationInstances = resource.getComponentInstancesRelations();
222 return componenRelationInstances;
225 private Resource getVfAsResourceObject(String resourceUniqueId) throws ClientProtocolException, IOException {
226 RestResponse getResource = ResourceRestUtils.getResource(resourceUniqueId);
227 Resource resource = ResponseParser.parseToObjectUsingMapper(getResource.getResponse(), Resource.class);
231 private List<ComponentInstance> getComponentInstancesList(String resourceUniqueId) throws Exception {
232 Resource resource = getVfAsResourceObject(resourceUniqueId);
233 List<ComponentInstance> componentInstances = resource.getComponentInstances();
234 return componentInstances;
238 public void associateCpToCpTest() throws Exception {
239 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.CP.toString());
241 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
242 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
244 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
246 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
248 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
251 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
252 capReqDefBeforeAssociate);
254 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
255 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
256 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
257 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
258 resourceDetailsVF.getUniqueId()));
260 CapReqDef capReqDef = getResourceReqCap();
262 requirementsBeforeAssociate.remove("tosca.capabilities.Container");
263 assertTrue(capReqDef.getRequirements().equals(requirementsBeforeAssociate));
265 List<CapabilityDefinition> list = capabilitiesBeforeAssociate.get("tosca.capabilities.Container");
266 for (CapabilityDefinition cap : list) {
267 cap.setMinOccurrences("0");
270 Map<String, List<CapabilityDefinition>> capabilitiesAfterAssociate = capReqDef.getCapabilities();
271 assertTrue(capabilitiesAfterAssociate.equals(capabilitiesBeforeAssociate));
274 private CapReqDef getResourceReqCap(ResourceReqDetails res) throws IOException {
275 RestResponse getResourceBeforeAssociate = ComponentRestUtils.getComponentRequirmentsCapabilities(designerUser,
277 CapReqDef capReqDef = ResponseParser.parseToObject(getResourceBeforeAssociate.getResponse(), CapReqDef.class);
281 private CapReqDef getResourceReqCap() throws IOException {
282 return getResourceReqCap(resourceDetailsVF);
286 public void associateCpToVLTest() throws Exception {
287 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
289 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
290 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
292 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
293 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
295 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
298 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
299 capReqDefBeforeAssociate);
301 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
302 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
303 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
304 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
305 resourceDetailsVF.getUniqueId()));
307 CapReqDef capReqDef = getResourceReqCap();
309 requirementsBeforeAssociate.remove("tosca.capabilities.Container");
310 assertTrue(capReqDef.getRequirements().equals(requirementsBeforeAssociate));
312 List<CapabilityDefinition> list = capabilitiesBeforeAssociate.get("tosca.capabilities.Container");
313 for (CapabilityDefinition cap : list) {
314 cap.setMinOccurrences("0");
317 Map<String, List<CapabilityDefinition>> capabilitiesAfterAssociate = capReqDef.getCapabilities();
318 assertTrue(capabilitiesAfterAssociate.equals(capabilitiesBeforeAssociate));
323 // ELLA - more informative error
325 public void associateCpToVlInVFCTest() throws Exception {
326 ResourceReqDetails vfcDetails = ElementFactory.getDefaultResourceByType("VFC100", NormativeTypesEnum.ROOT,
327 ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, designerUser.getUserId(), ResourceTypeEnum.VFC.toString());
328 RestResponse createVfcResponse = ResourceRestUtils.createResource(vfcDetails, designerUser);
329 ResourceRestUtils.checkCreateResponse(createVfcResponse);
331 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
333 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
334 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
336 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
338 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
339 capReqDefBeforeAssociate);
341 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
342 vfcDetails.getUniqueId(), ComponentTypeEnum.RESOURCE);
343 assertEquals("Check response code ", 400, associateInstances.getErrorCode().intValue());
345 // "messageId": "SVC4116",
346 // "text": "Error: Invalid Content.",
348 // "SoftCompRouter 1",
356 public void associateCpToVfTest() throws Exception {
357 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
359 ComponentInstance riCapInVfInstance = createComponentInstance(resourceDetailsCap, designerUser,
361 ComponentInstance riReqInVfInstance = createComponentInstance(resourceDetailsReq, designerUser,
364 ResourceReqDetails vfHigh = new ResourceReqDetails(resourceDetailsVF, "0.1");
365 vfHigh.setName("vfHigh");
366 vfHigh.setTags(new ArrayList<String>(Arrays.asList(vfHigh.getName())));
367 vfHigh.setResourceType(ResourceTypeEnum.VF.toString());
368 createResource(vfHigh, designerUser);
370 ComponentInstance riReq = createComponentInstance(resourceDetailsReq, designerUser, vfHigh);
371 LifecycleRestUtils.changeResourceState(resourceDetailsVF, designerUser, "0.1", LifeCycleStatesEnum.CHECKIN);
372 ComponentInstance riCap = createComponentInstance(resourceDetailsVF, designerUser, vfHigh);
374 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
376 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
377 capReqDefBeforeAssociate);
379 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
380 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
381 assertEquals("Check response code ", 409, associateInstances.getErrorCode().intValue());
382 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
383 associateInstances.getResponse());
384 // "messageId": "SVC4116",
385 // "text": "Error: Invalid Content.",
387 // "SoftCompRouter 1",
395 public void associateVfcToVfcNotFoundTest() throws Exception {
396 createTwoAtomicResourcesByType(ResourceTypeEnum.VFC.toString(), ResourceTypeEnum.VFC.toString());
398 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
399 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
400 riCap.setUniqueId("123");
402 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
404 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
405 capReqDefBeforeAssociate);
407 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
408 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
409 assertEquals("Check response code ", 400, associateInstances.getErrorCode().intValue());
410 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESOURCE_INSTANCE_BAD_REQUEST.name(),
411 new ArrayList<String>(), associateInstances.getResponse());
413 // "messageId": "SVC4116",
414 // "text": "Error: Invalid Content.",
416 // "SoftCompRouter 1",
417 // "012f6dcd-bcdf-4d9b-87be-ff1442b95831.5d265453-0b6a-4453-8f3d-57a253b88432.softcomprouter1",
422 public void associateCpToDeletedVfcTest() throws Exception {
423 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VFC.toString());
425 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
426 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
428 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
430 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
431 capReqDefBeforeAssociate);
433 RestResponse deleteResourceResponse = ResourceRestUtils.deleteResource(resourceDetailsCap.getUniqueId(),
434 designerUser.getUserId());
435 ResourceRestUtils.checkDeleteResponse(deleteResourceResponse);
437 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
438 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
439 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
440 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
441 resourceDetailsVF.getUniqueId()));
446 public void associateCpToDeletedVlTest() throws Exception {
447 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
449 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
450 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
452 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
454 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
455 capReqDefBeforeAssociate);
457 RestResponse deleteResourceResponse = ResourceRestUtils.deleteResource(resourceDetailsCap.getUniqueId(),
458 designerUser.getUserId());
459 ResourceRestUtils.checkDeleteResponse(deleteResourceResponse);
461 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
462 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
463 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
464 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
465 resourceDetailsVF.getUniqueId()));
470 public void associateCpToDeletedCpTest() throws Exception {
471 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.CP.toString());
473 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
474 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
476 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
478 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
479 capReqDefBeforeAssociate);
481 RestResponse deleteResourceResponse = ResourceRestUtils.deleteResource(resourceDetailsCap.getUniqueId(),
482 designerUser.getUserId());
483 ResourceRestUtils.checkDeleteResponse(deleteResourceResponse);
485 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
486 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
487 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
488 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
489 resourceDetailsVF.getUniqueId()));
495 public void associateCpToDeletedCpInstanceTest() throws Exception {
496 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.CP.toString());
498 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
499 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
501 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
502 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
504 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
507 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
508 capReqDefBeforeAssociate);
510 RestResponse deleteComponentInstance = ComponentInstanceRestUtils.deleteComponentInstance(designerUser,
511 resourceDetailsVF.getUniqueId(), riReq.getUniqueId(), ComponentTypeEnum.RESOURCE);
512 ComponentInstanceRestUtils.checkDeleteResponse(deleteComponentInstance);
514 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
515 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
516 assertEquals("Check response code ", 400, associateInstances.getErrorCode().intValue());
518 // "messageId": "SVC4116",
519 // "text": "Error: Invalid Content.",
521 // "7d6aca08-9321-4ea1-a781-c52c8214a30e.c0e63466-5283-44d8-adff-365c0885a6ba.softcomprouter1",
529 public void associateVfcToDeletedVFCInstanceTest() throws Exception {
530 createTwoAtomicResourcesByType(ResourceTypeEnum.VFC.toString(), ResourceTypeEnum.VFC.toString());
532 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
533 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
535 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
536 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
538 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
541 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
542 capReqDefBeforeAssociate);
544 RestResponse deleteComponentInstance = ComponentInstanceRestUtils.deleteComponentInstance(designerUser,
545 resourceDetailsVF.getUniqueId(), riReq.getUniqueId(), ComponentTypeEnum.RESOURCE);
546 ComponentInstanceRestUtils.checkDeleteResponse(deleteComponentInstance);
548 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
549 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
550 assertEquals("Check response code ", 400, associateInstances.getErrorCode().intValue());
552 // "messageId": "SVC4116",
553 // "text": "Error: Invalid Content.",
555 // "7d6aca08-9321-4ea1-a781-c52c8214a30e.c0e63466-5283-44d8-adff-365c0885a6ba.softcomprouter1",
562 public void associateWithDifferentOwnerOfVf() throws Exception {
563 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
565 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
566 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
568 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
570 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
571 capReqDefBeforeAssociate);
573 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
575 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
578 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef,
579 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER2), resourceDetailsVF.getUniqueId(),
580 ComponentTypeEnum.RESOURCE);
581 assertEquals("Check response code ", 409, associateInstances.getErrorCode().intValue());
582 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
583 associateInstances.getResponse());
585 CapReqDef capReqDef = getResourceReqCap();
587 Map<String, List<CapabilityDefinition>> capabilitiesAfterAssociate = capReqDef.getCapabilities();
588 Map<String, List<RequirementDefinition>> requirementsAfterAssociate = capReqDef.getRequirements();
590 assertTrue(capabilitiesAfterAssociate.equals(capabilitiesBeforeAssociate));
591 assertTrue(requirementsAfterAssociate.equals(requirementsBeforeAssociate));
595 public void associateWithTester() throws Exception {
596 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
598 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
599 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
601 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
603 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
604 capReqDefBeforeAssociate);
606 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
608 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
611 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef,
612 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), resourceDetailsVF.getUniqueId(),
613 ComponentTypeEnum.RESOURCE);
614 assertEquals("Check response code ", 409, associateInstances.getErrorCode().intValue());
615 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
616 associateInstances.getResponse());
618 CapReqDef capReqDef = getResourceReqCap();
620 Map<String, List<CapabilityDefinition>> capabilitiesAfterAssociate = capReqDef.getCapabilities();
621 Map<String, List<RequirementDefinition>> requirementsAfterAssociate = capReqDef.getRequirements();
623 assertTrue(capabilitiesAfterAssociate.equals(capabilitiesBeforeAssociate));
624 assertTrue(requirementsAfterAssociate.equals(requirementsBeforeAssociate));
629 public void associateCpToVLIntoVFNotFound() throws Exception {
630 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
632 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
633 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
635 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
637 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
638 capReqDefBeforeAssociate);
640 String uidNotFound = "123";
641 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
642 uidNotFound, ComponentTypeEnum.RESOURCE);
643 assertEquals("Check response code ", 404, associateInstances.getErrorCode().intValue());
644 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESOURCE_NOT_FOUND.name(),
645 new ArrayList<String>(Arrays.asList("")), associateInstances.getResponse());
647 // {"serviceException":{"messageId":"SVC4063","text":"Error: Requested
648 // '%1' resource was not found.","variables":[""]}}}
653 public void associateCpToVlWithMissingUid() throws Exception {
654 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
656 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
657 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
659 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
661 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
662 capReqDefBeforeAssociate);
664 requirementDef.setToNode("");
665 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
666 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
667 assertEquals("Check response code ", 400, associateInstances.getErrorCode().intValue());
668 // ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(),
669 // new ArrayList<String>(), associateInstances.getResponse());
671 // "messageId": "SVC4116",
672 // "text": "Error: Invalid Content.",
674 // "SoftCompRouter 1",
675 // "fd3a689b-fa1c-4105-933d-d1310e642f05.95bce626-ce73-413b-8c14-2388d1589d5c.softcomprouter1",
681 public void associateInServiceWithUidOfVf() throws Exception {
682 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
684 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
685 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
687 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
689 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
690 capReqDefBeforeAssociate);
692 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
693 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.SERVICE);
694 assertEquals("Check response code ", 404, associateInstances.getErrorCode().intValue());
695 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.SERVICE_NOT_FOUND.name(),
696 new ArrayList<String>(Arrays.asList("")), associateInstances.getResponse());
700 public void associateCpToVl_DifferentOwners() throws Exception {
701 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString(), designerUser,
702 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER2));
704 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
705 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
707 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
709 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
711 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
714 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
715 capReqDefBeforeAssociate);
717 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
718 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
719 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
720 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
721 resourceDetailsVF.getUniqueId()));
723 CapReqDef capReqDef = getResourceReqCap();
725 requirementsBeforeAssociate.remove("tosca.capabilities.Container");
726 assertTrue(capReqDef.getRequirements().equals(requirementsBeforeAssociate));
728 List<CapabilityDefinition> list = capabilitiesBeforeAssociate.get("tosca.capabilities.Container");
729 for (CapabilityDefinition cap : list) {
730 cap.setMinOccurrences("0");
733 Map<String, List<CapabilityDefinition>> capabilitiesAfterAssociate = capReqDef.getCapabilities();
734 assertTrue(capabilitiesAfterAssociate.equals(capabilitiesBeforeAssociate));
737 @Test(enabled = false)
738 public void associateToNotCheckedoutVf() throws Exception {
739 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
741 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
742 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
744 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
745 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
747 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
750 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
751 capReqDefBeforeAssociate);
753 RestResponse changeResourceStateToCheckin = LifecycleRestUtils.changeResourceState(resourceDetailsVF,
754 designerUser, LifeCycleStatesEnum.CHECKIN);
755 LifecycleRestUtils.checkSuccess(changeResourceStateToCheckin);
757 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
758 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
759 assertEquals("Check response code ", 409, associateInstances.getErrorCode().intValue());
760 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
761 associateInstances.getResponse());
763 CapReqDef capReqDef = getResourceReqCap();
764 assertTrue(capReqDef.getRequirements().equals(requirementsBeforeAssociate));
765 assertTrue(capReqDef.getCapabilities().equals(capabilitiesBeforeAssociate));
767 String firstUniqueId = resourceDetailsVF.getUniqueId();
771 RestResponse changeResourceStateToCheckout = LifecycleRestUtils.changeResourceState(resourceDetailsVF,
772 designerUser, LifeCycleStatesEnum.CHECKOUT);
773 LifecycleRestUtils.checkSuccess(changeResourceStateToCheckout);
774 String secondUniqueId = resourceDetailsVF.getUniqueId();
776 CapReqDef capReqDefAfterFirstCheckout = getResourceReqCap();
777 Map<String, List<CapabilityDefinition>> capabilitiesAfterFirstCheckout = capReqDefAfterFirstCheckout
779 Map<String, List<RequirementDefinition>> requirementsAfterFirstCheckout = capReqDefAfterFirstCheckout
782 requirementDef = setUidsOfInstancesAfterLifecycleStateChange(riReq, riCap, capReqDefBeforeAssociate);
784 RestResponse firstAssociateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef,
785 designerUser, resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
786 assertEquals("Check response code ", STATUS_CODE_SUCCESS, firstAssociateInstances.getErrorCode().intValue());
787 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
788 resourceDetailsVF.getUniqueId()));
790 CapReqDef capReqDefAfterFirstAssociate = getResourceReqCap();
791 Map<String, List<CapabilityDefinition>> capabilitiesAfterFirstAssociate = capReqDefAfterFirstAssociate
793 Map<String, List<RequirementDefinition>> requirementsAfterFirstAssociate = capReqDefAfterFirstAssociate
796 requirementsAfterFirstCheckout.remove("tosca.capabilities.Container");
797 assertTrue(requirementsAfterFirstAssociate.equals(requirementsAfterFirstCheckout));
798 assertTrue(capabilitiesAfterFirstAssociate.equals(capabilitiesAfterFirstCheckout));
800 resourceDetailsVF.setUniqueId(firstUniqueId);
801 CapReqDef capReqDefOfFirstVersion = getResourceReqCap();
802 Map<String, List<CapabilityDefinition>> capabilitiesOfFirstVersion = capReqDefOfFirstVersion.getCapabilities();
803 Map<String, List<RequirementDefinition>> requirementsOfFirstVersion = capReqDefOfFirstVersion.getRequirements();
805 assertTrue(getComponentInstancesRelations(resourceDetailsVF.getUniqueId()).isEmpty());
806 assertTrue(requirementsBeforeAssociate.equals(requirementsOfFirstVersion));
807 assertTrue(capabilitiesBeforeAssociate.equals(capabilitiesOfFirstVersion));
810 resourceDetailsVF.setUniqueId(secondUniqueId);
811 RestResponse changeResourceStateToCheckin2 = LifecycleRestUtils.changeResourceState(resourceDetailsVF,
812 designerUser, LifeCycleStatesEnum.CHECKIN);
813 LifecycleRestUtils.checkSuccess(changeResourceStateToCheckin2);
814 RestResponse changeResourceStateToCheckout2 = LifecycleRestUtils.changeResourceState(resourceDetailsVF,
815 designerUser, LifeCycleStatesEnum.CHECKOUT);
816 LifecycleRestUtils.checkSuccess(changeResourceStateToCheckout2);
818 List<RequirementCapabilityRelDef> componentInstancesRelations = getComponentInstancesRelations(
819 resourceDetailsVF.getUniqueId());
820 assertFalse(componentInstancesRelations.isEmpty());
821 assertEquals(1, componentInstancesRelations.size());
822 List<ComponentInstance> componentInstancesList = getComponentInstancesList(resourceDetailsVF.getUniqueId());
823 for (ComponentInstance comp : componentInstancesList) {
824 String instanceUid = comp.getUniqueId();
825 assertTrue(checkNodesInRelations(instanceUid, componentInstancesRelations.get(0)));
827 assertEquals(2, componentInstancesList.size());
831 private RequirementCapabilityRelDef setUidsOfInstancesAfterLifecycleStateChange(ComponentInstance riReq,
832 ComponentInstance riCap, CapReqDef capReqDefBeforeAssociate)
833 throws ClientProtocolException, IOException, Exception {
834 RequirementCapabilityRelDef requirementDef;
835 // RestResponse getResourceResponse =
836 // ResourceRestUtils.getResource(resourceDetailsVF.getUniqueId());
837 // Resource resource_0_2 =
838 // ResponseParser.parseToObjectUsingMapper(getResourceResponse.getResponse(),
840 // List<ComponentInstance> componentInstances =
841 // resource_0_2.getComponentInstances();
842 List<ComponentInstance> componentInstances = getComponentInstancesList(resourceDetailsVF.getUniqueId());
844 for (ComponentInstance comp : componentInstances) {
845 if (comp.getName().equals(riReq.getName())) {
846 riReq.setUniqueId(comp.getUniqueId());
847 } else if (comp.getName().equals(riCap.getName())) {
848 riCap.setUniqueId(comp.getUniqueId());
851 requirementDef = setRelationshipBetweenInstances(riReq, riCap, capReqDefBeforeAssociate);
852 return requirementDef;
855 private boolean checkNodesInRelations(String instanceUid, RequirementCapabilityRelDef relation) {
856 if (relation.getToNode().equals(instanceUid)) {
858 } else if (relation.getFromNode().equals(instanceUid)) {
866 public void associateOneOfTwoCPsToVl_ThenDiscocciate() throws Exception {
867 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
868 ResourceReqDetails secondResourceDetailsReq = new ResourceReqDetails(resourceDetailsReq, "0.1");
869 secondResourceDetailsReq.setName("secondCP");
870 secondResourceDetailsReq.setTags(Arrays.asList(secondResourceDetailsReq.getName()));
871 createAtomicResource(secondResourceDetailsReq, designerUser);
873 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
874 ComponentInstance riReq2 = createComponentInstance(secondResourceDetailsReq);
875 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
877 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
879 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
881 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
884 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
885 capReqDefBeforeAssociate);
887 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
888 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
889 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
890 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
891 resourceDetailsVF.getUniqueId()));
893 CapReqDef capReqDef = getResourceReqCap();
895 List<RequirementDefinition> expectedList = requirementsBeforeAssociate.get("tosca.capabilities.Container");
896 for (RequirementDefinition req : expectedList) {
897 if (req.getOwnerName().equals(riReq2.getName())) {
898 expectedList = new ArrayList<RequirementDefinition>(Arrays.asList(req));
902 requirementsBeforeAssociate.put("tosca.capabilities.Container", expectedList);
903 assertTrue(capReqDef.getRequirements().equals(requirementsBeforeAssociate));
905 List<CapabilityDefinition> list = capabilitiesBeforeAssociate.get("tosca.capabilities.Container");
906 for (CapabilityDefinition cap : list) {
907 cap.setMinOccurrences("0");
910 Map<String, List<CapabilityDefinition>> capabilitiesAfterAssociate = capReqDef.getCapabilities();
911 assertTrue(capabilitiesAfterAssociate.equals(capabilitiesBeforeAssociate));
913 // second relationship
915 RequirementCapabilityRelDef secondRequirementDef = setRelationshipBetweenInstances(riReq2, riCap,
916 capReqDefBeforeAssociate);
917 RestResponse secondAssociateInstances = ComponentInstanceRestUtils.associateInstances(secondRequirementDef,
918 designerUser, resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
919 assertEquals("Check response code ", STATUS_CODE_SUCCESS, secondAssociateInstances.getErrorCode().intValue());
920 assertTrue(checkRealtionship(secondRequirementDef.getFromNode(), secondRequirementDef.getToNode(),
921 resourceDetailsVF.getUniqueId()));
923 CapReqDef capReqDefAfterSecondAssociation = getResourceReqCap();
925 requirementsBeforeAssociate.remove("tosca.capabilities.Container");
926 assertTrue(capReqDefAfterSecondAssociation.getRequirements().equals(requirementsBeforeAssociate));
928 Map<String, List<CapabilityDefinition>> capabilitiesAfterSecondAssociate = capReqDefAfterSecondAssociation
930 assertTrue(capabilitiesAfterSecondAssociate.equals(capabilitiesBeforeAssociate));
934 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(secondRequirementDef,
935 designerUser, resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
936 assertEquals("Check response code ", STATUS_CODE_SUCCESS, dissociateInstances.getErrorCode().intValue());
937 assertTrue(getComponentInstancesRelations(resourceDetailsVF.getUniqueId()).isEmpty());
939 CapReqDef capReqDefAfterDissociation = getResourceReqCap();
940 Map<String, List<CapabilityDefinition>> capabilitiesAfterDissociate = capReqDefAfterDissociation
942 Map<String, List<RequirementDefinition>> requirementsAfterDissociate = capReqDefAfterDissociation
945 assertTrue(capabilitiesAfterDissociate.equals(capReqDef.getCapabilities()));
946 requirementsBeforeAssociate.put("tosca.capabilities.Container", expectedList);
947 assertTrue(requirementsAfterDissociate.equals(requirementsBeforeAssociate));
951 public void associateNotCompitableCapAndReq() throws Exception {
952 resourceDetailsReq = ElementFactory.getDefaultResourceByType("Database", NormativeTypesEnum.DATABASE,
953 ResourceCategoryEnum.NETWORK_L2_3_ROUTERS, designerUser.getUserId(), ResourceTypeEnum.CP.toString()); // resourceType
956 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
958 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
959 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
961 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
963 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
965 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
968 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
969 capReqDefBeforeAssociate);
970 assertTrue(requirementDef.getRelationships().size() == 1);
971 String requirement = requirementDef.getRelationships().get(0).getRelation().getRequirement();
972 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
973 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
974 assertEquals("Check response code ", 404, associateInstances.getErrorCode().intValue());
975 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESOURCE_INSTANCE_MATCH_NOT_FOUND.name(),
976 new ArrayList<String>(Arrays.asList(riReq.getName(), riCap.getName(), requirement)),
977 associateInstances.getResponse());
979 CapReqDef capReqDef = getResourceReqCap();
981 Map<String, List<CapabilityDefinition>> capabilitiesAfterAssociate = capReqDef.getCapabilities();
982 Map<String, List<RequirementDefinition>> requirementsAfterAssociate = capReqDef.getRequirements();
984 assertTrue(capabilitiesAfterAssociate.equals(capabilitiesBeforeAssociate));
985 assertTrue(requirementsAfterAssociate.equals(requirementsBeforeAssociate));
990 public void disassociateCpAndCpTest() throws Exception {
991 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.CP.toString());
993 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
994 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
996 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
998 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
999 capReqDefBeforeAssociate);
1000 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1002 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1005 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
1006 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1007 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
1008 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
1009 resourceDetailsVF.getUniqueId()));
1011 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef, designerUser,
1012 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1013 assertEquals("Check response code ", STATUS_CODE_SUCCESS, dissociateInstances.getErrorCode().intValue());
1014 assertTrue(getComponentInstancesRelations(resourceDetailsVF.getUniqueId()).isEmpty());
1016 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1018 List<RequirementDefinition> listOfRequierments = capReqDefAfterDissociate.getRequirements()
1019 .get("tosca.capabilities.Container");
1020 assertEquals("Check requirement", 1, listOfRequierments.size());
1021 assertTrue(capReqDefAfterDissociate.getRequirements().equals(requirementsBeforeAssociate));
1022 assertTrue(capReqDefAfterDissociate.getCapabilities().equals(capabilitiesBeforeAssociate));
1026 public void disassociateCpAndVfcTest() throws Exception {
1027 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VFC.toString());
1029 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1030 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1032 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1034 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1035 capReqDefBeforeAssociate);
1036 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1038 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1041 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
1042 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1043 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
1044 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
1045 resourceDetailsVF.getUniqueId()));
1047 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef, designerUser,
1048 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1049 assertEquals("Check response code ", STATUS_CODE_SUCCESS, dissociateInstances.getErrorCode().intValue());
1050 assertTrue(getComponentInstancesRelations(resourceDetailsVF.getUniqueId()).isEmpty());
1052 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1054 List<RequirementDefinition> listOfRequierments = capReqDefAfterDissociate.getRequirements()
1055 .get("tosca.capabilities.Container");
1056 assertEquals("Check requirement", 1, listOfRequierments.size());
1057 assertTrue(capReqDefAfterDissociate.getRequirements().equals(requirementsBeforeAssociate));
1058 assertTrue(capReqDefAfterDissociate.getCapabilities().equals(capabilitiesBeforeAssociate));
1062 public void disassociateCpAndVLTest() throws Exception {
1063 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
1065 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1066 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1068 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1070 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1071 capReqDefBeforeAssociate);
1072 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1074 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1077 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
1078 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1079 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
1080 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
1081 resourceDetailsVF.getUniqueId()));
1083 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef, designerUser,
1084 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1085 assertEquals("Check response code ", STATUS_CODE_SUCCESS, dissociateInstances.getErrorCode().intValue());
1086 assertTrue(getComponentInstancesRelations(resourceDetailsVF.getUniqueId()).isEmpty());
1088 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1090 List<RequirementDefinition> listOfRequierments = capReqDefAfterDissociate.getRequirements()
1091 .get("tosca.capabilities.Container");
1092 assertEquals("Check requirement", 1, listOfRequierments.size());
1093 assertTrue(capReqDefAfterDissociate.getRequirements().equals(requirementsBeforeAssociate));
1094 assertTrue(capReqDefAfterDissociate.getCapabilities().equals(capabilitiesBeforeAssociate));
1098 // in the error should we get the unique id of instances instead of names
1100 public void disassociateNotFoundAssociation() throws Exception {
1101 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
1103 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1104 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1106 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1108 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1109 capReqDefBeforeAssociate);
1110 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1112 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1114 String requirementName = requirementDef.getRelationships().get(0).getRelation().getRequirement();
1116 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef, designerUser,
1117 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1118 assertEquals("Check response code ", 404, dissociateInstances.getErrorCode().intValue());
1119 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESOURCE_INSTANCE_RELATION_NOT_FOUND.name(),
1120 new ArrayList<String>(Arrays.asList(riReq.getName(), riCap.getName(), requirementName)),
1121 dissociateInstances.getResponse());
1123 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1125 List<RequirementDefinition> listOfRequierments = capReqDefAfterDissociate.getRequirements()
1126 .get("tosca.capabilities.Container");
1127 assertEquals("Check requirement", 1, listOfRequierments.size());
1128 assertTrue(capReqDefAfterDissociate.getRequirements().equals(requirementsBeforeAssociate));
1129 assertTrue(capReqDefAfterDissociate.getCapabilities().equals(capabilitiesBeforeAssociate));
1134 public void disassociateRelationInVfNotFound() throws Exception {
1135 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
1137 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1138 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1140 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1142 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1143 capReqDefBeforeAssociate);
1144 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1146 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1149 String uidNotFound = "123";
1150 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef, designerUser,
1151 uidNotFound, ComponentTypeEnum.RESOURCE);
1152 assertEquals("Check response code ", 404, dissociateInstances.getErrorCode().intValue());
1153 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESOURCE_NOT_FOUND.name(),
1154 new ArrayList<String>(Arrays.asList(uidNotFound)), dissociateInstances.getResponse());
1156 // "serviceException": {
1157 // "messageId": "SVC4063",
1158 // "text": "Error: Requested \u0027%1\u0027 resource was not found.",
1165 public void disassociateWithDifferentDesigner() throws Exception {
1166 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
1168 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1169 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1171 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1173 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1174 capReqDefBeforeAssociate);
1175 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1177 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1180 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef,
1181 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER2), resourceDetailsVF.getUniqueId(),
1182 ComponentTypeEnum.RESOURCE);
1183 assertEquals("Check response code ", 409, dissociateInstances.getErrorCode().intValue());
1184 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
1185 dissociateInstances.getResponse());
1187 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1189 List<RequirementDefinition> listOfRequierments = capReqDefAfterDissociate.getRequirements()
1190 .get("tosca.capabilities.Container");
1191 assertEquals("Check requirement", 1, listOfRequierments.size());
1192 assertTrue(capReqDefAfterDissociate.getRequirements().equals(requirementsBeforeAssociate));
1193 assertTrue(capReqDefAfterDissociate.getCapabilities().equals(capabilitiesBeforeAssociate));
1198 public void disassociateWithTester() throws Exception {
1199 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
1201 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1202 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1204 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1206 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1207 capReqDefBeforeAssociate);
1208 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1210 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1213 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef,
1214 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), resourceDetailsVF.getUniqueId(),
1215 ComponentTypeEnum.RESOURCE);
1216 assertEquals("Check response code ", 409, dissociateInstances.getErrorCode().intValue());
1217 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
1218 dissociateInstances.getResponse());
1220 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1222 List<RequirementDefinition> listOfRequierments = capReqDefAfterDissociate.getRequirements()
1223 .get("tosca.capabilities.Container");
1224 assertNotNull("Requierment is null after disassociate with tester", listOfRequierments);
1225 assertEquals("Check requirement", 1, listOfRequierments.size());
1226 assertTrue(capReqDefAfterDissociate.getRequirements().equals(requirementsBeforeAssociate));
1227 assertTrue(capReqDefAfterDissociate.getCapabilities().equals(capabilitiesBeforeAssociate));
1231 public void disassociateServiceWithUidOfVF() throws Exception {
1232 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VFC.toString());
1234 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1235 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1237 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1239 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1240 capReqDefBeforeAssociate);
1242 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
1243 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1244 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
1245 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
1246 resourceDetailsVF.getUniqueId()));
1248 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef, designerUser,
1249 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.SERVICE);
1250 assertEquals("Check response code ", 404, dissociateInstances.getErrorCode().intValue());
1251 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.SERVICE_NOT_FOUND.name(),
1252 new ArrayList<String>(Arrays.asList("")), dissociateInstances.getResponse());
1254 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1256 List<RequirementDefinition> listOfRequierments = capReqDefAfterDissociate.getRequirements()
1257 .get("tosca.capabilities.Container");
1258 assertTrue(listOfRequierments == null);
1259 assertTrue(getComponentInstancesRelations(resourceDetailsVF.getUniqueId()).size() != 0);
1263 public void disassociateWithEmptyVfUid() throws Exception {
1264 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
1266 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1267 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1269 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1271 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1272 capReqDefBeforeAssociate);
1273 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1275 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1278 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
1279 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1280 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
1281 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
1282 resourceDetailsVF.getUniqueId()));
1284 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef, designerUser,
1285 "", ComponentTypeEnum.RESOURCE);
1286 assertEquals("Check response code ", 404, dissociateInstances.getErrorCode().intValue());
1288 CapReqDef capReqDef = getResourceReqCap();
1290 requirementsBeforeAssociate.remove("tosca.capabilities.Container");
1291 assertTrue(capReqDef.getRequirements().equals(requirementsBeforeAssociate));
1293 List<CapabilityDefinition> list = capabilitiesBeforeAssociate.get("tosca.capabilities.Container");
1294 for (CapabilityDefinition cap : list) {
1295 cap.setMinOccurrences("0");
1298 Map<String, List<CapabilityDefinition>> capabilitiesAfterAssociate = capReqDef.getCapabilities();
1299 assertTrue(capabilitiesAfterAssociate.equals(capabilitiesBeforeAssociate));
1303 public void disassociateOneComponentDeleted() throws Exception {
1304 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
1306 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1307 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1309 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1311 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1312 capReqDefBeforeAssociate);
1313 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1315 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1318 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
1319 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1321 RestResponse deleteResourceResponse = ResourceRestUtils.deleteResource(resourceDetailsCap.getUniqueId(),
1322 designerUser.getUserId());
1323 ResourceRestUtils.checkDeleteResponse(deleteResourceResponse);
1325 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef, designerUser,
1326 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1327 assertEquals("Check response code ", STATUS_CODE_SUCCESS, dissociateInstances.getErrorCode().intValue());
1328 assertTrue(getComponentInstancesRelations(resourceDetailsVF.getUniqueId()).isEmpty());
1330 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1332 List<RequirementDefinition> listOfRequierments = capReqDefAfterDissociate.getRequirements()
1333 .get("tosca.capabilities.Container");
1334 assertEquals("Check requirement", 1, listOfRequierments.size());
1335 assertTrue(capReqDefAfterDissociate.getRequirements().equals(requirementsBeforeAssociate));
1336 assertTrue(capReqDefAfterDissociate.getCapabilities().equals(capabilitiesBeforeAssociate));
1340 public void disassociateNotCheckedoutVf() throws Exception {
1341 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
1343 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1344 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1346 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1347 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1349 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1352 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1353 capReqDefBeforeAssociate);
1355 RestResponse changeResourceStateToCheckin = LifecycleRestUtils.changeResourceState(resourceDetailsVF,
1356 designerUser, LifeCycleStatesEnum.CHECKIN);
1357 LifecycleRestUtils.checkSuccess(changeResourceStateToCheckin);
1359 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef, designerUser,
1360 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1361 assertEquals("Check response code ", 409, dissociateInstances.getErrorCode().intValue());
1362 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
1363 dissociateInstances.getResponse());
1365 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1366 assertTrue(capReqDefAfterDissociate.getRequirements().equals(requirementsBeforeAssociate));
1367 assertTrue(capReqDefAfterDissociate.getCapabilities().equals(capabilitiesBeforeAssociate));
1369 RestResponse changeResourceStateToCheckout = LifecycleRestUtils.changeResourceState(resourceDetailsVF,
1370 designerUser, LifeCycleStatesEnum.CHECKOUT);
1371 LifecycleRestUtils.checkSuccess(changeResourceStateToCheckout);
1373 requirementDef = setUidsOfInstancesAfterLifecycleStateChange(riReq, riCap, capReqDefBeforeAssociate);
1375 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
1376 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1377 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
1378 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
1379 resourceDetailsVF.getUniqueId()));
1381 RestResponse secondDisociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef,
1382 designerUser, resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1383 assertEquals("Check response code ", STATUS_CODE_SUCCESS, secondDisociateInstances.getErrorCode().intValue());
1384 assertTrue(getComponentInstancesRelations(resourceDetailsVF.getUniqueId()).isEmpty());
1386 RestResponse changeResourceStateToCheckout2 = LifecycleRestUtils.changeResourceState(resourceDetailsVF,
1387 designerUser, LifeCycleStatesEnum.CHECKIN);
1388 LifecycleRestUtils.checkSuccess(changeResourceStateToCheckout2);
1389 RestResponse changeResourceStateToCheckout3 = LifecycleRestUtils.changeResourceState(resourceDetailsVF,
1390 designerUser, LifeCycleStatesEnum.CHECKOUT);
1391 LifecycleRestUtils.checkSuccess(changeResourceStateToCheckout3);
1393 assertTrue(getComponentInstancesRelations(resourceDetailsVF.getUniqueId()).isEmpty());