test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/resource/ComponentRelationshipInVfTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.ci.tests.execute.resource;
  22
  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;
  41
  42 import java.io.IOException;
  43 import java.util.ArrayList;
  44 import java.util.Arrays;
  45 import java.util.List;
  46 import java.util.Map;
  47
  48 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_SUCCESS;
  49 import static org.testng.AssertJUnit.*;
  50
  51 public class ComponentRelationshipInVfTest extends ComponentBaseTest {
  52
  53         public ComponentRelationshipInVfTest() {
  54                 super(new TestName(), ComponentRelationshipInVfTest.class.getName());
  55         }
  56
  57         private ResourceReqDetails resourceDetailsVF;
  58         private User designerUser;
  59         private User adminUser;
  60         private User testerUser;
  61         private ResourceReqDetails resourceDetailsReq;
  62         private ResourceReqDetails resourceDetailsCap;
  63
  64         @BeforeMethod
  65         public void before() throws Exception {
  66                 designerUser = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
  67                 adminUser = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
  68                 testerUser = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
  69
  70                 resourceDetailsVF = ElementFactory.getDefaultResourceByType("VF100", NormativeTypesEnum.ROOT,
  71                                 ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, designerUser.getUserId(), ResourceTypeEnum.VF.toString());
  72                 createResource(resourceDetailsVF, designerUser);
  73
  74                 resourceDetailsReq = ElementFactory.getDefaultResourceByType("SoftCompRouter",
  75                                 NormativeTypesEnum.SOFTWARE_COMPONENT, ResourceCategoryEnum.NETWORK_L2_3_ROUTERS,
  76                                 designerUser.getUserId(), ResourceTypeEnum.CP.toString()); // resourceType
  77                                                                                                                                                         // =
  78                                                                                                                                                         // VFC
  79                 resourceDetailsCap = ElementFactory.getDefaultResourceByType("MyCompute", NormativeTypesEnum.COMPUTE,
  80                                 ResourceCategoryEnum.NETWORK_L2_3_ROUTERS, designerUser.getUserId(), ResourceTypeEnum.CP.toString()); // resourceType
  81                                                                                                                                                                                                                                                 // =
  82                                                                                                                                                                                                                                                 // VFC
  83
  84         }
  85
  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);
  91         }
  92
  93         private void createAtomicResource(ResourceReqDetails resourceDetails, User user) throws Exception {
  94                 createResource(resourceDetails, user);
  95         }
  96
  97         private RequirementCapabilityRelDef setRelationshipBetweenInstances(ComponentInstance riReq,
  98                         ComponentInstance riCap, CapReqDef capReqDef) throws Exception {
  99
 100                 String capbilityUid = capReqDef.getCapabilities().get("tosca.capabilities.Container").get(0).getUniqueId();
 101                 String requirementUid = capReqDef.getRequirements().get("tosca.capabilities.Container").get(0).getUniqueId();
 102
 103                 RequirementCapabilityRelDef requirementDef = new RequirementCapabilityRelDef();
 104                 requirementDef.setFromNode(riReq.getUniqueId());
 105                 requirementDef.setToNode(riCap.getUniqueId());
 106
 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;
 122         }
 123
 124         private ComponentInstance createComponentInstance(ResourceReqDetails res) throws Exception {
 125                 return createComponentInstance(res, designerUser);
 126         }
 127
 128         private ComponentInstance createComponentInstance(ResourceReqDetails res, User user, ResourceReqDetails vf)
 129                         throws Exception {
 130                 RestResponse response = ResourceRestUtils.createResourceInstance(res, user, vf.getUniqueId());
 131                 ResourceRestUtils.checkCreateResponse(response);
 132                 ComponentInstance compInstance = ResponseParser.parseToObject(response.getResponse(), ComponentInstance.class);
 133                 return compInstance;
 134         }
 135
 136         private ComponentInstance createComponentInstance(ResourceReqDetails res, User user) throws Exception {
 137                 return createComponentInstance(res, user, resourceDetailsVF);
 138         }
 139
 140         private void createTwoAtomicResourcesByType(String reqType, String capType, User user1, User user2)
 141                         throws Exception {
 142                 resourceDetailsReq.setResourceType(reqType);
 143                 createAtomicResource(resourceDetailsReq, user1);
 144                 resourceDetailsCap.setResourceType(capType);
 145                 createAtomicResource(resourceDetailsCap, user2);
 146         }
 147
 148         private void createTwoAtomicResourcesByType(String reqType, String capType) throws Exception {
 149                 createTwoAtomicResourcesByType(reqType, capType, designerUser, designerUser);
 150         }
 151
 152         @Test
 153         public void associateInVF() throws Exception {
 154
 155                 createTwoAtomicResourcesByType(ResourceTypeEnum.VFC.toString(), ResourceTypeEnum.VFC.toString());
 156
 157                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 158                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 159
 160                 CapReqDef capReqDef = getResourceReqCap();
 161
 162                 List<CapabilityDefinition> capList = capReqDef.getCapabilities().get("tosca.capabilities.Container");
 163                 List<RequirementDefinition> reqList = capReqDef.getRequirements().get("tosca.capabilities.Container");
 164
 165                 RequirementCapabilityRelDef requirementDef = new RequirementCapabilityRelDef();
 166                 requirementDef.setFromNode(riReq.getUniqueId());
 167                 requirementDef.setToNode(riCap.getUniqueId());
 168
 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);
 183
 184                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
 185                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
 186                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
 187
 188                 RestResponse getResourceResponse = ComponentRestUtils.getComponentRequirmentsCapabilities(designerUser,
 189                                 resourceDetailsVF);
 190                 capReqDef = ResponseParser.parseToObject(getResourceResponse.getResponse(), CapReqDef.class);
 191
 192                 List<RequirementDefinition> list = capReqDef.getRequirements().get("tosca.capabilities.Container");
 193                 assertEquals("Check requirement", null, list);
 194
 195                 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef, designerUser,
 196                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
 197                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, dissociateInstances.getErrorCode().intValue());
 198
 199                 getResourceResponse = ComponentRestUtils.getComponentRequirmentsCapabilities(designerUser, resourceDetailsVF);
 200                 capReqDef = ResponseParser.parseToObject(getResourceResponse.getResponse(), CapReqDef.class);
 201
 202                 list = capReqDef.getRequirements().get("tosca.capabilities.Container");
 203                 assertEquals("Check requirement", 1, list.size());
 204         }
 205
 206         //////////////////////////////// Q A //////////////////////////////
 207         private boolean checkRealtionship(String fromNode, String toNode, String resourceUniqueId) throws Exception {
 208                 List<RequirementCapabilityRelDef> componentInstancesRelations = getComponentInstancesRelations(
 209                                 resourceUniqueId);
 210                 RequirementCapabilityRelDef requirementCapabilityRelDef = componentInstancesRelations.get(0);
 211                 boolean fromNodeCheck = requirementCapabilityRelDef.getFromNode().equals(fromNode);
 212                 boolean toNodeCheck = requirementCapabilityRelDef.getToNode().equals(toNode);
 213
 214                 return fromNodeCheck && toNodeCheck;
 215         }
 216
 217         private List<RequirementCapabilityRelDef> getComponentInstancesRelations(String resourceUniqueId)
 218                         throws ClientProtocolException, IOException {
 219                 Resource resource = getVfAsResourceObject(resourceUniqueId);
 220                 List<RequirementCapabilityRelDef> componenRelationInstances = resource.getComponentInstancesRelations();
 221
 222                 return componenRelationInstances;
 223         }
 224
 225         private Resource getVfAsResourceObject(String resourceUniqueId) throws ClientProtocolException, IOException {
 226                 RestResponse getResource = ResourceRestUtils.getResource(resourceUniqueId);
 227                 Resource resource = ResponseParser.parseToObjectUsingMapper(getResource.getResponse(), Resource.class);
 228                 return resource;
 229         }
 230
 231         private List<ComponentInstance> getComponentInstancesList(String resourceUniqueId) throws Exception {
 232                 Resource resource = getVfAsResourceObject(resourceUniqueId);
 233                 List<ComponentInstance> componentInstances = resource.getComponentInstances();
 234                 return componentInstances;
 235         }
 236
 237         @Test
 238         public void associateCpToCpTest() throws Exception {
 239                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.CP.toString());
 240
 241                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 242                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 243
 244                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 245
 246                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
 247                                 .getCapabilities();
 248                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
 249                                 .getRequirements();
 250
 251                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 252                                 capReqDefBeforeAssociate);
 253
 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()));
 259
 260                 CapReqDef capReqDef = getResourceReqCap();
 261
 262                 requirementsBeforeAssociate.remove("tosca.capabilities.Container");
 263                 assertTrue(capReqDef.getRequirements().equals(requirementsBeforeAssociate));
 264
 265                 List<CapabilityDefinition> list = capabilitiesBeforeAssociate.get("tosca.capabilities.Container");
 266                 for (CapabilityDefinition cap : list) {
 267                         cap.setMinOccurrences("0");
 268                 }
 269
 270                 Map<String, List<CapabilityDefinition>> capabilitiesAfterAssociate = capReqDef.getCapabilities();
 271                 assertTrue(capabilitiesAfterAssociate.equals(capabilitiesBeforeAssociate));
 272         }
 273
 274         private CapReqDef getResourceReqCap(ResourceReqDetails res) throws IOException {
 275                 RestResponse getResourceBeforeAssociate = ComponentRestUtils.getComponentRequirmentsCapabilities(designerUser,
 276                                 resourceDetailsVF);
 277                 CapReqDef capReqDef = ResponseParser.parseToObject(getResourceBeforeAssociate.getResponse(), CapReqDef.class);
 278                 return capReqDef;
 279         }
 280
 281         private CapReqDef getResourceReqCap() throws IOException {
 282                 return getResourceReqCap(resourceDetailsVF);
 283         }
 284
 285         @Test
 286         public void associateCpToVLTest() throws Exception {
 287                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
 288
 289                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 290                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 291
 292                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 293                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
 294                                 .getCapabilities();
 295                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
 296                                 .getRequirements();
 297
 298                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 299                                 capReqDefBeforeAssociate);
 300
 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()));
 306
 307                 CapReqDef capReqDef = getResourceReqCap();
 308
 309                 requirementsBeforeAssociate.remove("tosca.capabilities.Container");
 310                 assertTrue(capReqDef.getRequirements().equals(requirementsBeforeAssociate));
 311
 312                 List<CapabilityDefinition> list = capabilitiesBeforeAssociate.get("tosca.capabilities.Container");
 313                 for (CapabilityDefinition cap : list) {
 314                         cap.setMinOccurrences("0");
 315                 }
 316
 317                 Map<String, List<CapabilityDefinition>> capabilitiesAfterAssociate = capReqDef.getCapabilities();
 318                 assertTrue(capabilitiesAfterAssociate.equals(capabilitiesBeforeAssociate));
 319
 320         }
 321
 322         // Error handling
 323         // ELLA - more informative error
 324         @Test
 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);
 330
 331                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
 332
 333                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 334                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 335
 336                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 337
 338                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 339                                 capReqDefBeforeAssociate);
 340
 341                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
 342                                 vfcDetails.getUniqueId(), ComponentTypeEnum.RESOURCE);
 343                 assertEquals("Check response code ", 400, associateInstances.getErrorCode().intValue());
 344
 345                 // "messageId": "SVC4116",
 346                 // "text": "Error: Invalid Content.",
 347                 // "variables": [
 348                 // "SoftCompRouter 1",
 349                 // "MyCompute 2",
 350                 // "host"
 351                 // ]
 352         }
 353
 354         // Error handling
 355         @Test
 356         public void associateCpToVfTest() throws Exception {
 357                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
 358
 359                 ComponentInstance riCapInVfInstance = createComponentInstance(resourceDetailsCap, designerUser,
 360                                 resourceDetailsVF);
 361                 ComponentInstance riReqInVfInstance = createComponentInstance(resourceDetailsReq, designerUser,
 362                                 resourceDetailsVF);
 363
 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);
 369
 370                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq, designerUser, vfHigh);
 371                 LifecycleRestUtils.changeResourceState(resourceDetailsVF, designerUser, "0.1", LifeCycleStatesEnum.CHECKIN);
 372                 ComponentInstance riCap = createComponentInstance(resourceDetailsVF, designerUser, vfHigh);
 373
 374                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 375
 376                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 377                                 capReqDefBeforeAssociate);
 378
 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.",
 386                 // "variables": [
 387                 // "SoftCompRouter 1",
 388                 // "VF100 2",
 389                 // "host"
 390                 // ]
 391         }
 392
 393         // Error handling
 394         @Test
 395         public void associateVfcToVfcNotFoundTest() throws Exception {
 396                 createTwoAtomicResourcesByType(ResourceTypeEnum.VFC.toString(), ResourceTypeEnum.VFC.toString());
 397
 398                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 399                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 400                 riCap.setUniqueId("123");
 401
 402                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 403
 404                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 405                                 capReqDefBeforeAssociate);
 406
 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());
 412
 413                 // "messageId": "SVC4116",
 414                 // "text": "Error: Invalid Content.",
 415                 // "variables": [
 416                 // "SoftCompRouter 1",
 417                 // "012f6dcd-bcdf-4d9b-87be-ff1442b95831.5d265453-0b6a-4453-8f3d-57a253b88432.softcomprouter1",
 418                 // "host"
 419         }
 420
 421         @Test
 422         public void associateCpToDeletedVfcTest() throws Exception {
 423                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VFC.toString());
 424
 425                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 426                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 427
 428                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 429
 430                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 431                                 capReqDefBeforeAssociate);
 432
 433                 RestResponse deleteResourceResponse = ResourceRestUtils.deleteResource(resourceDetailsCap.getUniqueId(),
 434                                 designerUser.getUserId());
 435                 ResourceRestUtils.checkDeleteResponse(deleteResourceResponse);
 436
 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()));
 442
 443         }
 444
 445         @Test
 446         public void associateCpToDeletedVlTest() throws Exception {
 447                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
 448
 449                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 450                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 451
 452                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 453
 454                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 455                                 capReqDefBeforeAssociate);
 456
 457                 RestResponse deleteResourceResponse = ResourceRestUtils.deleteResource(resourceDetailsCap.getUniqueId(),
 458                                 designerUser.getUserId());
 459                 ResourceRestUtils.checkDeleteResponse(deleteResourceResponse);
 460
 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()));
 466
 467         }
 468
 469         @Test
 470         public void associateCpToDeletedCpTest() throws Exception {
 471                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.CP.toString());
 472
 473                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 474                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 475
 476                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 477
 478                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 479                                 capReqDefBeforeAssociate);
 480
 481                 RestResponse deleteResourceResponse = ResourceRestUtils.deleteResource(resourceDetailsCap.getUniqueId(),
 482                                 designerUser.getUserId());
 483                 ResourceRestUtils.checkDeleteResponse(deleteResourceResponse);
 484
 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()));
 490
 491         }
 492
 493         // Error handling
 494         @Test
 495         public void associateCpToDeletedCpInstanceTest() throws Exception {
 496                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.CP.toString());
 497
 498                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 499                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 500
 501                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 502                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
 503                                 .getCapabilities();
 504                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
 505                                 .getRequirements();
 506
 507                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 508                                 capReqDefBeforeAssociate);
 509
 510                 RestResponse deleteComponentInstance = ComponentInstanceRestUtils.deleteComponentInstance(designerUser,
 511                                 resourceDetailsVF.getUniqueId(), riReq.getUniqueId(), ComponentTypeEnum.RESOURCE);
 512                 ComponentInstanceRestUtils.checkDeleteResponse(deleteComponentInstance);
 513
 514                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
 515                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
 516                 assertEquals("Check response code ", 400, associateInstances.getErrorCode().intValue());
 517
 518                 // "messageId": "SVC4116",
 519                 // "text": "Error: Invalid Content.",
 520                 // "variables": [
 521                 // "7d6aca08-9321-4ea1-a781-c52c8214a30e.c0e63466-5283-44d8-adff-365c0885a6ba.softcomprouter1",
 522                 // "MyCompute 2",
 523                 // "host"
 524                 // ]
 525         }
 526
 527         // Error handling
 528         @Test
 529         public void associateVfcToDeletedVFCInstanceTest() throws Exception {
 530                 createTwoAtomicResourcesByType(ResourceTypeEnum.VFC.toString(), ResourceTypeEnum.VFC.toString());
 531
 532                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 533                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 534
 535                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 536                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
 537                                 .getCapabilities();
 538                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
 539                                 .getRequirements();
 540
 541                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 542                                 capReqDefBeforeAssociate);
 543
 544                 RestResponse deleteComponentInstance = ComponentInstanceRestUtils.deleteComponentInstance(designerUser,
 545                                 resourceDetailsVF.getUniqueId(), riReq.getUniqueId(), ComponentTypeEnum.RESOURCE);
 546                 ComponentInstanceRestUtils.checkDeleteResponse(deleteComponentInstance);
 547
 548                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
 549                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
 550                 assertEquals("Check response code ", 400, associateInstances.getErrorCode().intValue());
 551
 552                 // "messageId": "SVC4116",
 553                 // "text": "Error: Invalid Content.",
 554                 // "variables": [
 555                 // "7d6aca08-9321-4ea1-a781-c52c8214a30e.c0e63466-5283-44d8-adff-365c0885a6ba.softcomprouter1",
 556                 // "MyCompute 2",
 557                 // "host"
 558                 // ]
 559         }
 560
 561         @Test
 562         public void associateWithDifferentOwnerOfVf() throws Exception {
 563                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
 564
 565                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 566                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 567
 568                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 569
 570                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 571                                 capReqDefBeforeAssociate);
 572
 573                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
 574                                 .getCapabilities();
 575                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
 576                                 .getRequirements();
 577
 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());
 584
 585                 CapReqDef capReqDef = getResourceReqCap();
 586
 587                 Map<String, List<CapabilityDefinition>> capabilitiesAfterAssociate = capReqDef.getCapabilities();
 588                 Map<String, List<RequirementDefinition>> requirementsAfterAssociate = capReqDef.getRequirements();
 589
 590                 assertTrue(capabilitiesAfterAssociate.equals(capabilitiesBeforeAssociate));
 591                 assertTrue(requirementsAfterAssociate.equals(requirementsBeforeAssociate));
 592         }
 593
 594         @Test
 595         public void associateWithTester() throws Exception {
 596                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
 597
 598                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 599                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 600
 601                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 602
 603                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 604                                 capReqDefBeforeAssociate);
 605
 606                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
 607                                 .getCapabilities();
 608                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
 609                                 .getRequirements();
 610
 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());
 617
 618                 CapReqDef capReqDef = getResourceReqCap();
 619
 620                 Map<String, List<CapabilityDefinition>> capabilitiesAfterAssociate = capReqDef.getCapabilities();
 621                 Map<String, List<RequirementDefinition>> requirementsAfterAssociate = capReqDef.getRequirements();
 622
 623                 assertTrue(capabilitiesAfterAssociate.equals(capabilitiesBeforeAssociate));
 624                 assertTrue(requirementsAfterAssociate.equals(requirementsBeforeAssociate));
 625         }
 626
 627         // Error handling
 628         @Test
 629         public void associateCpToVLIntoVFNotFound() throws Exception {
 630                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
 631
 632                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 633                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 634
 635                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 636
 637                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 638                                 capReqDefBeforeAssociate);
 639
 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());
 646
 647                 // {"serviceException":{"messageId":"SVC4063","text":"Error: Requested
 648                 // '%1' resource was not found.","variables":[""]}}}
 649         }
 650
 651         // Error Handling
 652         @Test
 653         public void associateCpToVlWithMissingUid() throws Exception {
 654                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
 655
 656                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 657                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 658
 659                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 660
 661                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 662                                 capReqDefBeforeAssociate);
 663
 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());
 670
 671                 // "messageId": "SVC4116",
 672                 // "text": "Error: Invalid Content.",
 673                 // "variables": [
 674                 // "SoftCompRouter 1",
 675                 // "fd3a689b-fa1c-4105-933d-d1310e642f05.95bce626-ce73-413b-8c14-2388d1589d5c.softcomprouter1",
 676                 // "host"
 677                 // ]
 678         }
 679
 680         @Test
 681         public void associateInServiceWithUidOfVf() throws Exception {
 682                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
 683
 684                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 685                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 686
 687                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 688
 689                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 690                                 capReqDefBeforeAssociate);
 691
 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());
 697         }
 698
 699         @Test
 700         public void associateCpToVl_DifferentOwners() throws Exception {
 701                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString(), designerUser,
 702                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER2));
 703
 704                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 705                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 706
 707                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 708
 709                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
 710                                 .getCapabilities();
 711                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
 712                                 .getRequirements();
 713
 714                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 715                                 capReqDefBeforeAssociate);
 716
 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()));
 722
 723                 CapReqDef capReqDef = getResourceReqCap();
 724
 725                 requirementsBeforeAssociate.remove("tosca.capabilities.Container");
 726                 assertTrue(capReqDef.getRequirements().equals(requirementsBeforeAssociate));
 727
 728                 List<CapabilityDefinition> list = capabilitiesBeforeAssociate.get("tosca.capabilities.Container");
 729                 for (CapabilityDefinition cap : list) {
 730                         cap.setMinOccurrences("0");
 731                 }
 732
 733                 Map<String, List<CapabilityDefinition>> capabilitiesAfterAssociate = capReqDef.getCapabilities();
 734                 assertTrue(capabilitiesAfterAssociate.equals(capabilitiesBeforeAssociate));
 735         }
 736
 737         @Test(enabled = false)
 738         public void associateToNotCheckedoutVf() throws Exception {
 739                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
 740
 741                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 742                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 743
 744                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 745                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
 746                                 .getCapabilities();
 747                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
 748                                 .getRequirements();
 749
 750                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 751                                 capReqDefBeforeAssociate);
 752
 753                 RestResponse changeResourceStateToCheckin = LifecycleRestUtils.changeResourceState(resourceDetailsVF,
 754                                 designerUser, LifeCycleStatesEnum.CHECKIN);
 755                 LifecycleRestUtils.checkSuccess(changeResourceStateToCheckin);
 756
 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());
 762
 763                 CapReqDef capReqDef = getResourceReqCap();
 764                 assertTrue(capReqDef.getRequirements().equals(requirementsBeforeAssociate));
 765                 assertTrue(capReqDef.getCapabilities().equals(capabilitiesBeforeAssociate));
 766
 767                 String firstUniqueId = resourceDetailsVF.getUniqueId();
 768
 769                 // checkout
 770
 771                 RestResponse changeResourceStateToCheckout = LifecycleRestUtils.changeResourceState(resourceDetailsVF,
 772                                 designerUser, LifeCycleStatesEnum.CHECKOUT);
 773                 LifecycleRestUtils.checkSuccess(changeResourceStateToCheckout);
 774                 String secondUniqueId = resourceDetailsVF.getUniqueId();
 775
 776                 CapReqDef capReqDefAfterFirstCheckout = getResourceReqCap();
 777                 Map<String, List<CapabilityDefinition>> capabilitiesAfterFirstCheckout = capReqDefAfterFirstCheckout
 778                                 .getCapabilities();
 779                 Map<String, List<RequirementDefinition>> requirementsAfterFirstCheckout = capReqDefAfterFirstCheckout
 780                                 .getRequirements();
 781
 782                 requirementDef = setUidsOfInstancesAfterLifecycleStateChange(riReq, riCap, capReqDefBeforeAssociate);
 783
 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()));
 789
 790                 CapReqDef capReqDefAfterFirstAssociate = getResourceReqCap();
 791                 Map<String, List<CapabilityDefinition>> capabilitiesAfterFirstAssociate = capReqDefAfterFirstAssociate
 792                                 .getCapabilities();
 793                 Map<String, List<RequirementDefinition>> requirementsAfterFirstAssociate = capReqDefAfterFirstAssociate
 794                                 .getRequirements();
 795
 796                 requirementsAfterFirstCheckout.remove("tosca.capabilities.Container");
 797                 assertTrue(requirementsAfterFirstAssociate.equals(requirementsAfterFirstCheckout));
 798                 assertTrue(capabilitiesAfterFirstAssociate.equals(capabilitiesAfterFirstCheckout));
 799
 800                 resourceDetailsVF.setUniqueId(firstUniqueId);
 801                 CapReqDef capReqDefOfFirstVersion = getResourceReqCap();
 802                 Map<String, List<CapabilityDefinition>> capabilitiesOfFirstVersion = capReqDefOfFirstVersion.getCapabilities();
 803                 Map<String, List<RequirementDefinition>> requirementsOfFirstVersion = capReqDefOfFirstVersion.getRequirements();
 804
 805                 assertTrue(getComponentInstancesRelations(resourceDetailsVF.getUniqueId()).isEmpty());
 806                 assertTrue(requirementsBeforeAssociate.equals(requirementsOfFirstVersion));
 807                 assertTrue(capabilitiesBeforeAssociate.equals(capabilitiesOfFirstVersion));
 808
 809                 // checkin-checkout
 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);
 817
 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)));
 826                 }
 827                 assertEquals(2, componentInstancesList.size());
 828
 829         }
 830
 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(),
 839                 // Resource.class);
 840                 // List<ComponentInstance> componentInstances =
 841                 // resource_0_2.getComponentInstances();
 842                 List<ComponentInstance> componentInstances = getComponentInstancesList(resourceDetailsVF.getUniqueId());
 843
 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());
 849                         }
 850                 }
 851                 requirementDef = setRelationshipBetweenInstances(riReq, riCap, capReqDefBeforeAssociate);
 852                 return requirementDef;
 853         }
 854
 855         private boolean checkNodesInRelations(String instanceUid, RequirementCapabilityRelDef relation) {
 856                 if (relation.getToNode().equals(instanceUid)) {
 857                         return true;
 858                 } else if (relation.getFromNode().equals(instanceUid)) {
 859                         return true;
 860                 } else {
 861                         return false;
 862                 }
 863         }
 864
 865         @Test
 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);
 872
 873                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 874                 ComponentInstance riReq2 = createComponentInstance(secondResourceDetailsReq);
 875                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 876
 877                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 878
 879                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
 880                                 .getCapabilities();
 881                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
 882                                 .getRequirements();
 883
 884                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 885                                 capReqDefBeforeAssociate);
 886
 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()));
 892
 893                 CapReqDef capReqDef = getResourceReqCap();
 894
 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));
 899                                 break;
 900                         }
 901                 }
 902                 requirementsBeforeAssociate.put("tosca.capabilities.Container", expectedList);
 903                 assertTrue(capReqDef.getRequirements().equals(requirementsBeforeAssociate));
 904
 905                 List<CapabilityDefinition> list = capabilitiesBeforeAssociate.get("tosca.capabilities.Container");
 906                 for (CapabilityDefinition cap : list) {
 907                         cap.setMinOccurrences("0");
 908                 }
 909
 910                 Map<String, List<CapabilityDefinition>> capabilitiesAfterAssociate = capReqDef.getCapabilities();
 911                 assertTrue(capabilitiesAfterAssociate.equals(capabilitiesBeforeAssociate));
 912
 913                 // second relationship
 914
 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()));
 922
 923                 CapReqDef capReqDefAfterSecondAssociation = getResourceReqCap();
 924
 925                 requirementsBeforeAssociate.remove("tosca.capabilities.Container");
 926                 assertTrue(capReqDefAfterSecondAssociation.getRequirements().equals(requirementsBeforeAssociate));
 927
 928                 Map<String, List<CapabilityDefinition>> capabilitiesAfterSecondAssociate = capReqDefAfterSecondAssociation
 929                                 .getCapabilities();
 930                 assertTrue(capabilitiesAfterSecondAssociate.equals(capabilitiesBeforeAssociate));
 931
 932                 // dissociate
 933
 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());
 938
 939                 CapReqDef capReqDefAfterDissociation = getResourceReqCap();
 940                 Map<String, List<CapabilityDefinition>> capabilitiesAfterDissociate = capReqDefAfterDissociation
 941                                 .getCapabilities();
 942                 Map<String, List<RequirementDefinition>> requirementsAfterDissociate = capReqDefAfterDissociation
 943                                 .getRequirements();
 944
 945                 assertTrue(capabilitiesAfterDissociate.equals(capReqDef.getCapabilities()));
 946                 requirementsBeforeAssociate.put("tosca.capabilities.Container", expectedList);
 947                 assertTrue(requirementsAfterDissociate.equals(requirementsBeforeAssociate));
 948         }
 949
 950         @Test
 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
 954                                                                                                                                                                                                                                                 // =
 955                                                                                                                                                                                                                                                 // VFC
 956                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
 957
 958                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 959                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 960
 961                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 962
 963                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
 964                                 .getCapabilities();
 965                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
 966                                 .getRequirements();
 967
 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());
 978
 979                 CapReqDef capReqDef = getResourceReqCap();
 980
 981                 Map<String, List<CapabilityDefinition>> capabilitiesAfterAssociate = capReqDef.getCapabilities();
 982                 Map<String, List<RequirementDefinition>> requirementsAfterAssociate = capReqDef.getRequirements();
 983
 984                 assertTrue(capabilitiesAfterAssociate.equals(capabilitiesBeforeAssociate));
 985                 assertTrue(requirementsAfterAssociate.equals(requirementsBeforeAssociate));
 986
 987         }
 988
 989         @Test
 990         public void disassociateCpAndCpTest() throws Exception {
 991                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.CP.toString());
 992
 993                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 994                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 995
 996                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 997
 998                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 999                                 capReqDefBeforeAssociate);
1000                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1001                                 .getCapabilities();
1002                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1003                                 .getRequirements();
1004
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()));
1010
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());
1015
1016                 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1017
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));
1023         }
1024
1025         @Test
1026         public void disassociateCpAndVfcTest() throws Exception {
1027                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VFC.toString());
1028
1029                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1030                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1031
1032                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1033
1034                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1035                                 capReqDefBeforeAssociate);
1036                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1037                                 .getCapabilities();
1038                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1039                                 .getRequirements();
1040
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()));
1046
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());
1051
1052                 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1053
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));
1059         }
1060
1061         @Test
1062         public void disassociateCpAndVLTest() throws Exception {
1063                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
1064
1065                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1066                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1067
1068                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1069
1070                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1071                                 capReqDefBeforeAssociate);
1072                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1073                                 .getCapabilities();
1074                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1075                                 .getRequirements();
1076
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()));
1082
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());
1087
1088                 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1089
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));
1095         }
1096
1097         // Error handliing
1098         // in the error should we get the unique id of instances instead of names
1099         @Test
1100         public void disassociateNotFoundAssociation() throws Exception {
1101                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
1102
1103                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1104                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1105
1106                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1107
1108                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1109                                 capReqDefBeforeAssociate);
1110                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1111                                 .getCapabilities();
1112                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1113                                 .getRequirements();
1114                 String requirementName = requirementDef.getRelationships().get(0).getRelation().getRequirement();
1115
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());
1122
1123                 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1124
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));
1130         }
1131
1132         // Error handliing
1133         @Test
1134         public void disassociateRelationInVfNotFound() throws Exception {
1135                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
1136
1137                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1138                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1139
1140                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1141
1142                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1143                                 capReqDefBeforeAssociate);
1144                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1145                                 .getCapabilities();
1146                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1147                                 .getRequirements();
1148
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());
1155
1156                 // "serviceException": {
1157                 // "messageId": "SVC4063",
1158                 // "text": "Error: Requested \u0027%1\u0027 resource was not found.",
1159                 // "variables": [
1160                 // ""
1161                 // ]
1162         }
1163
1164         @Test
1165         public void disassociateWithDifferentDesigner() throws Exception {
1166                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
1167
1168                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1169                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1170
1171                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1172
1173                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1174                                 capReqDefBeforeAssociate);
1175                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1176                                 .getCapabilities();
1177                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1178                                 .getRequirements();
1179
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());
1186
1187                 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1188
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));
1194
1195         }
1196
1197         @Test
1198         public void disassociateWithTester() throws Exception {
1199                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
1200
1201                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1202                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1203
1204                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1205
1206                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1207                                 capReqDefBeforeAssociate);
1208                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1209                                 .getCapabilities();
1210                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1211                                 .getRequirements();
1212
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());
1219
1220                 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1221
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));
1228         }
1229
1230         @Test
1231         public void disassociateServiceWithUidOfVF() throws Exception {
1232                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VFC.toString());
1233
1234                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1235                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1236
1237                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1238
1239                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1240                                 capReqDefBeforeAssociate);
1241
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()));
1247
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());
1253
1254                 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1255
1256                 List<RequirementDefinition> listOfRequierments = capReqDefAfterDissociate.getRequirements()
1257                                 .get("tosca.capabilities.Container");
1258                 assertTrue(listOfRequierments == null);
1259                 assertTrue(getComponentInstancesRelations(resourceDetailsVF.getUniqueId()).size() != 0);
1260         }
1261
1262         @Test
1263         public void disassociateWithEmptyVfUid() throws Exception {
1264                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
1265
1266                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1267                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1268
1269                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1270
1271                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1272                                 capReqDefBeforeAssociate);
1273                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1274                                 .getCapabilities();
1275                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1276                                 .getRequirements();
1277
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()));
1283
1284                 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef, designerUser,
1285                                 "", ComponentTypeEnum.RESOURCE);
1286                 assertEquals("Check response code ", 404, dissociateInstances.getErrorCode().intValue());
1287
1288                 CapReqDef capReqDef = getResourceReqCap();
1289
1290                 requirementsBeforeAssociate.remove("tosca.capabilities.Container");
1291                 assertTrue(capReqDef.getRequirements().equals(requirementsBeforeAssociate));
1292
1293                 List<CapabilityDefinition> list = capabilitiesBeforeAssociate.get("tosca.capabilities.Container");
1294                 for (CapabilityDefinition cap : list) {
1295                         cap.setMinOccurrences("0");
1296                 }
1297
1298                 Map<String, List<CapabilityDefinition>> capabilitiesAfterAssociate = capReqDef.getCapabilities();
1299                 assertTrue(capabilitiesAfterAssociate.equals(capabilitiesBeforeAssociate));
1300         }
1301
1302         @Test
1303         public void disassociateOneComponentDeleted() throws Exception {
1304                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
1305
1306                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1307                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1308
1309                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1310
1311                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1312                                 capReqDefBeforeAssociate);
1313                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1314                                 .getCapabilities();
1315                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1316                                 .getRequirements();
1317
1318                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
1319                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1320
1321                 RestResponse deleteResourceResponse = ResourceRestUtils.deleteResource(resourceDetailsCap.getUniqueId(),
1322                                 designerUser.getUserId());
1323                 ResourceRestUtils.checkDeleteResponse(deleteResourceResponse);
1324
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());
1329
1330                 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1331
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));
1337         }
1338
1339         @Test
1340         public void disassociateNotCheckedoutVf() throws Exception {
1341                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
1342
1343                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1344                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1345
1346                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1347                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1348                                 .getCapabilities();
1349                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1350                                 .getRequirements();
1351
1352                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1353                                 capReqDefBeforeAssociate);
1354
1355                 RestResponse changeResourceStateToCheckin = LifecycleRestUtils.changeResourceState(resourceDetailsVF,
1356                                 designerUser, LifeCycleStatesEnum.CHECKIN);
1357                 LifecycleRestUtils.checkSuccess(changeResourceStateToCheckin);
1358
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());
1364
1365                 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1366                 assertTrue(capReqDefAfterDissociate.getRequirements().equals(requirementsBeforeAssociate));
1367                 assertTrue(capReqDefAfterDissociate.getCapabilities().equals(capabilitiesBeforeAssociate));
1368
1369                 RestResponse changeResourceStateToCheckout = LifecycleRestUtils.changeResourceState(resourceDetailsVF,
1370                                 designerUser, LifeCycleStatesEnum.CHECKOUT);
1371                 LifecycleRestUtils.checkSuccess(changeResourceStateToCheckout);
1372
1373                 requirementDef = setUidsOfInstancesAfterLifecycleStateChange(riReq, riCap, capReqDefBeforeAssociate);
1374
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()));
1380
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());
1385
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);
1392
1393                 assertTrue(getComponentInstancesRelations(resourceDetailsVF.getUniqueId()).isEmpty());
1394
1395         }
1396
1397 }