asdc-tests/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 static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_SUCCESS;
  24 import static org.testng.AssertJUnit.assertEquals;
  25 import static org.testng.AssertJUnit.assertFalse;
  26 import static org.testng.AssertJUnit.assertNotNull;
  27 import static org.testng.AssertJUnit.assertTrue;
  28
  29 import java.io.IOException;
  30 import java.util.ArrayList;
  31 import java.util.Arrays;
  32 import java.util.List;
  33 import java.util.Map;
  34
  35 import org.apache.http.client.ClientProtocolException;
  36 import org.junit.rules.TestName;
  37 import org.openecomp.sdc.be.dao.api.ActionStatus;
  38 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  39 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  40 import org.openecomp.sdc.be.model.CapReqDef;
  41 import org.openecomp.sdc.be.model.CapabilityDefinition;
  42 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
  43 import org.openecomp.sdc.be.model.ComponentInstance;
  44 import org.openecomp.sdc.be.model.RelationshipImpl;
  45 import org.openecomp.sdc.be.model.RelationshipInfo;
  46 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
  47 import org.openecomp.sdc.be.model.RequirementDefinition;
  48 import org.openecomp.sdc.be.model.Resource;
  49 import org.openecomp.sdc.be.model.User;
  50 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  51 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  52 import org.openecomp.sdc.ci.tests.datatypes.enums.LifeCycleStatesEnum;
  53 import org.openecomp.sdc.ci.tests.datatypes.enums.NormativeTypesEnum;
  54 import org.openecomp.sdc.ci.tests.datatypes.enums.ResourceCategoryEnum;
  55 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  56 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  57 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  58 import org.openecomp.sdc.ci.tests.utils.rest.ComponentInstanceRestUtils;
  59 import org.openecomp.sdc.ci.tests.utils.rest.ComponentRestUtils;
  60 import org.openecomp.sdc.ci.tests.utils.rest.LifecycleRestUtils;
  61 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils;
  62 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  63 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  64 import org.testng.annotations.BeforeMethod;
  65 import org.testng.annotations.Test;
  66
  67 public class ComponentRelationshipInVfTest extends ComponentBaseTest {
  68
  69         public ComponentRelationshipInVfTest() {
  70                 super(new TestName(), ComponentRelationshipInVfTest.class.getName());
  71         }
  72
  73         private ResourceReqDetails resourceDetailsVF;
  74         private User designerUser;
  75         private ResourceReqDetails resourceDetailsReq;
  76         private ResourceReqDetails resourceDetailsCap;
  77
  78         @BeforeMethod
  79         public void before() throws Exception {
  80                 designerUser = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
  81
  82                 resourceDetailsVF = ElementFactory.getDefaultResourceByType("VF100", NormativeTypesEnum.ROOT,
  83                                 ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, designerUser.getUserId(), ResourceTypeEnum.VF.toString());
  84                 createResource(resourceDetailsVF, designerUser);
  85
  86                 resourceDetailsReq = ElementFactory.getDefaultResourceByType("SoftCompRouter",
  87                                 NormativeTypesEnum.SOFTWARE_COMPONENT, ResourceCategoryEnum.NETWORK_L2_3_ROUTERS,
  88                                 designerUser.getUserId(), ResourceTypeEnum.CP.toString()); // resourceType
  89                                                                                                                                                         // =
  90                                                                                                                                                         // VFC
  91                 resourceDetailsCap = ElementFactory.getDefaultResourceByType("ciMyCompute", NormativeTypesEnum.COMPUTE,
  92                                 ResourceCategoryEnum.NETWORK_L2_3_ROUTERS, designerUser.getUserId(), ResourceTypeEnum.CP.toString()); // resourceType
  93                                                                                                                                                                                                                                                 // =
  94                                                                                                                                                                                                                                                 // VFC
  95
  96         }
  97
  98         private void createResource(ResourceReqDetails resourceDetails, User user) throws Exception, IOException {
  99                 RestResponse createResourceResponse = ResourceRestUtils.createResource(resourceDetails, user);
 100                 ResourceRestUtils.checkCreateResponse(createResourceResponse);
 101                 if (!resourceDetails.getResourceType().equals("VF"))
 102                         LifecycleRestUtils.changeResourceState(resourceDetails, user, "0.1", LifeCycleStatesEnum.CHECKIN);
 103         }
 104
 105         private void createAtomicResource(ResourceReqDetails resourceDetails, User user) throws Exception {
 106                 createResource(resourceDetails, user);
 107         }
 108
 109         private RequirementCapabilityRelDef setRelationshipBetweenInstances(ComponentInstance riReq,
 110                         ComponentInstance riCap, CapReqDef capReqDef) throws Exception {
 111
 112                 String capbilityUid = capReqDef.getCapabilities().get("tosca.capabilities.Container").get(0).getUniqueId();
 113                 String requirementUid = capReqDef.getRequirements().get("tosca.capabilities.Container").get(0).getUniqueId();
 114
 115                 RequirementCapabilityRelDef requirementDef = new RequirementCapabilityRelDef();
 116                 requirementDef.setFromNode(riReq.getUniqueId());
 117                 requirementDef.setToNode(riCap.getUniqueId());
 118
 119                 RelationshipInfo pair = new RelationshipInfo();
 120                 pair.setRequirementOwnerId(riReq.getUniqueId());
 121                 pair.setCapabilityOwnerId(riCap.getUniqueId());
 122                 pair.setRequirement("host");
 123                 RelationshipImpl relationship = new RelationshipImpl();
 124                 relationship.setType("tosca.capabilities.Container");
 125                 pair.setRelationships(relationship);
 126                 pair.setCapabilityUid(capbilityUid);
 127                 pair.setRequirementUid(requirementUid);
 128                 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
 129                 CapabilityRequirementRelationship capReqRel = new CapabilityRequirementRelationship();
 130                 capReqRel.setRelation(pair);
 131                 relationships.add(capReqRel);
 132                 requirementDef.setRelationships(relationships);
 133                 return requirementDef;
 134         }
 135
 136         private ComponentInstance createComponentInstance(ResourceReqDetails res) throws Exception {
 137                 return createComponentInstance(res, designerUser);
 138         }
 139
 140         private ComponentInstance createComponentInstance(ResourceReqDetails res, User user, ResourceReqDetails vf)
 141                         throws Exception {
 142                 RestResponse response = ResourceRestUtils.createResourceInstance(res, user, vf.getUniqueId());
 143                 ResourceRestUtils.checkCreateResponse(response);
 144                 ComponentInstance compInstance = ResponseParser.parseToObject(response.getResponse(), ComponentInstance.class);
 145                 return compInstance;
 146         }
 147
 148         private ComponentInstance createComponentInstance(ResourceReqDetails res, User user) throws Exception {
 149                 return createComponentInstance(res, user, resourceDetailsVF);
 150         }
 151
 152         private void createTwoAtomicResourcesByType(String reqType, String capType, User user1, User user2)
 153                         throws Exception {
 154                 resourceDetailsReq.setResourceType(reqType);
 155                 createAtomicResource(resourceDetailsReq, user1);
 156                 resourceDetailsCap.setResourceType(capType);
 157                 createAtomicResource(resourceDetailsCap, user2);
 158         }
 159
 160         private void createTwoAtomicResourcesByType(String reqType, String capType) throws Exception {
 161                 createTwoAtomicResourcesByType(reqType, capType, designerUser, designerUser);
 162         }
 163
 164         @Test
 165         public void associateInVF() throws Exception {
 166
 167                 createTwoAtomicResourcesByType(ResourceTypeEnum.VFC.toString(), ResourceTypeEnum.VFC.toString());
 168
 169                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 170                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 171
 172                 CapReqDef capReqDef = getResourceReqCap();
 173
 174                 List<CapabilityDefinition> capList = capReqDef.getCapabilities().get("tosca.capabilities.Container");
 175                 List<RequirementDefinition> reqList = capReqDef.getRequirements().get("tosca.capabilities.Container");
 176
 177                 RequirementCapabilityRelDef requirementDef = new RequirementCapabilityRelDef();
 178                 requirementDef.setFromNode(riReq.getUniqueId());
 179                 requirementDef.setToNode(riCap.getUniqueId());
 180
 181                 RelationshipInfo pair = new RelationshipInfo();
 182                 pair.setRequirementOwnerId(riReq.getUniqueId());
 183                 pair.setCapabilityOwnerId(riCap.getUniqueId());
 184                 pair.setRequirement("host");
 185                 RelationshipImpl relationship = new RelationshipImpl();
 186                 relationship.setType("tosca.capabilities.Container");
 187                 pair.setRelationships(relationship);
 188                 pair.setCapabilityUid(capList.get(0).getUniqueId());
 189                 pair.setRequirementUid(reqList.get(0).getUniqueId());
 190                 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
 191                 CapabilityRequirementRelationship capReqRel = new CapabilityRequirementRelationship();
 192                 capReqRel.setRelation(pair);
 193                 relationships.add(capReqRel);
 194                 requirementDef.setRelationships(relationships);
 195
 196                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
 197                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
 198                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
 199
 200                 RestResponse getResourceResponse = ComponentRestUtils.getComponentRequirmentsCapabilities(designerUser,
 201                                 resourceDetailsVF);
 202                 capReqDef = ResponseParser.parseToObject(getResourceResponse.getResponse(), CapReqDef.class);
 203
 204                 List<RequirementDefinition> list = capReqDef.getRequirements().get("tosca.capabilities.Container");
 205                 assertEquals("Check requirement", null, list);
 206
 207                 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef, designerUser,
 208                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
 209                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, dissociateInstances.getErrorCode().intValue());
 210
 211                 getResourceResponse = ComponentRestUtils.getComponentRequirmentsCapabilities(designerUser, resourceDetailsVF);
 212                 capReqDef = ResponseParser.parseToObject(getResourceResponse.getResponse(), CapReqDef.class);
 213
 214                 list = capReqDef.getRequirements().get("tosca.capabilities.Container");
 215                 assertEquals("Check requirement", 1, list.size());
 216         }
 217
 218         //////////////////////////////// Q A //////////////////////////////
 219         private boolean checkRealtionship(String fromNode, String toNode, String resourceUniqueId) throws Exception {
 220                 List<RequirementCapabilityRelDef> componentInstancesRelations = getComponentInstancesRelations(
 221                                 resourceUniqueId);
 222                 RequirementCapabilityRelDef requirementCapabilityRelDef = componentInstancesRelations.get(0);
 223                 boolean fromNodeCheck = requirementCapabilityRelDef.getFromNode().equals(fromNode);
 224                 boolean toNodeCheck = requirementCapabilityRelDef.getToNode().equals(toNode);
 225
 226                 return fromNodeCheck && toNodeCheck;
 227         }
 228
 229         private List<RequirementCapabilityRelDef> getComponentInstancesRelations(String resourceUniqueId)
 230                         throws ClientProtocolException, IOException {
 231                 Resource resource = getVfAsResourceObject(resourceUniqueId);
 232                 List<RequirementCapabilityRelDef> componenRelationInstances = resource.getComponentInstancesRelations();
 233
 234                 return componenRelationInstances;
 235         }
 236
 237         private Resource getVfAsResourceObject(String resourceUniqueId) throws ClientProtocolException, IOException {
 238                 RestResponse getResource = ResourceRestUtils.getResource(resourceUniqueId);
 239                 Resource resource = ResponseParser.parseToObjectUsingMapper(getResource.getResponse(), Resource.class);
 240                 return resource;
 241         }
 242
 243         private List<ComponentInstance> getComponentInstancesList(String resourceUniqueId) throws Exception {
 244                 Resource resource = getVfAsResourceObject(resourceUniqueId);
 245                 List<ComponentInstance> componentInstances = resource.getComponentInstances();
 246                 return componentInstances;
 247         }
 248
 249         @Test
 250         public void associateCpToCpTest() throws Exception {
 251                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.CP.toString());
 252
 253                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 254                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 255
 256                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 257
 258                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
 259                                 .getCapabilities();
 260                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
 261                                 .getRequirements();
 262
 263                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 264                                 capReqDefBeforeAssociate);
 265
 266                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
 267                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
 268                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
 269                 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
 270                                 resourceDetailsVF.getUniqueId()));
 271
 272                 CapReqDef capReqDef = getResourceReqCap();
 273
 274                 requirementsBeforeAssociate.remove("tosca.capabilities.Container");
 275                 assertTrue(capReqDef.getRequirements().equals(requirementsBeforeAssociate));
 276
 277                 List<CapabilityDefinition> list = capabilitiesBeforeAssociate.get("tosca.capabilities.Container");
 278                 for (CapabilityDefinition cap : list) {
 279                         cap.setMinOccurrences("0");
 280                 }
 281
 282                 Map<String, List<CapabilityDefinition>> capabilitiesAfterAssociate = capReqDef.getCapabilities();
 283                 assertTrue(capabilitiesAfterAssociate.equals(capabilitiesBeforeAssociate));
 284         }
 285
 286         private CapReqDef getResourceReqCap(ResourceReqDetails res) throws IOException {
 287                 RestResponse getResourceBeforeAssociate = ComponentRestUtils.getComponentRequirmentsCapabilities(designerUser,
 288                                 resourceDetailsVF);
 289                 CapReqDef capReqDef = ResponseParser.parseToObject(getResourceBeforeAssociate.getResponse(), CapReqDef.class);
 290                 return capReqDef;
 291         }
 292
 293         private CapReqDef getResourceReqCap() throws IOException {
 294                 return getResourceReqCap(resourceDetailsVF);
 295         }
 296
 297         @Test
 298         public void associateCpToVLTest() throws Exception {
 299                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
 300
 301                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 302                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 303
 304                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 305                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
 306                                 .getCapabilities();
 307                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
 308                                 .getRequirements();
 309
 310                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 311                                 capReqDefBeforeAssociate);
 312
 313                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
 314                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
 315                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
 316                 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
 317                                 resourceDetailsVF.getUniqueId()));
 318
 319                 CapReqDef capReqDef = getResourceReqCap();
 320
 321                 requirementsBeforeAssociate.remove("tosca.capabilities.Container");
 322                 assertTrue(capReqDef.getRequirements().equals(requirementsBeforeAssociate));
 323
 324                 List<CapabilityDefinition> list = capabilitiesBeforeAssociate.get("tosca.capabilities.Container");
 325                 for (CapabilityDefinition cap : list) {
 326                         cap.setMinOccurrences("0");
 327                 }
 328
 329                 Map<String, List<CapabilityDefinition>> capabilitiesAfterAssociate = capReqDef.getCapabilities();
 330                 assertTrue(capabilitiesAfterAssociate.equals(capabilitiesBeforeAssociate));
 331
 332         }
 333
 334         // Error handling
 335         // ELLA - more informative error
 336         @Test
 337         public void associateCpToVlInVFCTest() throws Exception {
 338                 ResourceReqDetails vfcDetails = ElementFactory.getDefaultResourceByType("VFC100", NormativeTypesEnum.ROOT,
 339                                 ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, designerUser.getUserId(), ResourceTypeEnum.VFC.toString());
 340                 RestResponse createVfcResponse = ResourceRestUtils.createResource(vfcDetails, designerUser);
 341                 ResourceRestUtils.checkCreateResponse(createVfcResponse);
 342
 343                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
 344
 345                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 346                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 347
 348                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 349
 350                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 351                                 capReqDefBeforeAssociate);
 352
 353                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
 354                                 vfcDetails.getUniqueId(), ComponentTypeEnum.RESOURCE);
 355                 assertEquals("Check response code ", 400, associateInstances.getErrorCode().intValue());
 356
 357                 // "messageId": "SVC4116",
 358                 // "text": "Error: Invalid Content.",
 359                 // "variables": [
 360                 // "SoftCompRouter 1",
 361                 // "MyCompute 2",
 362                 // "host"
 363                 // ]
 364         }
 365
 366         // Error handling
 367         @Test
 368         public void associateCpToVfTest() throws Exception {
 369                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
 370
 371                 createComponentInstance(resourceDetailsCap, designerUser, resourceDetailsVF);
 372                 createComponentInstance(resourceDetailsReq, designerUser, resourceDetailsVF);
 373
 374                 ResourceReqDetails vfHigh = new ResourceReqDetails(resourceDetailsVF, "0.1");
 375                 vfHigh.setName("vfHigh");
 376                 vfHigh.setTags(new ArrayList<String>(Arrays.asList(vfHigh.getName())));
 377                 vfHigh.setResourceType(ResourceTypeEnum.VF.toString());
 378                 createResource(vfHigh, designerUser);
 379
 380                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq, designerUser, vfHigh);
 381                 LifecycleRestUtils.changeResourceState(resourceDetailsVF, designerUser, "0.1", LifeCycleStatesEnum.CHECKIN);
 382                 ComponentInstance riCap = createComponentInstance(resourceDetailsVF, designerUser, vfHigh);
 383
 384                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 385
 386                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 387                                 capReqDefBeforeAssociate);
 388
 389                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
 390                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
 391                 assertEquals("Check response code ", 409, associateInstances.getErrorCode().intValue());
 392                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
 393                                 associateInstances.getResponse());
 394                 // "messageId": "SVC4116",
 395                 // "text": "Error: Invalid Content.",
 396                 // "variables": [
 397                 // "SoftCompRouter 1",
 398                 // "VF100 2",
 399                 // "host"
 400                 // ]
 401         }
 402
 403         // Error handling
 404         @Test
 405         public void associateVfcToVfcNotFoundTest() throws Exception {
 406                 createTwoAtomicResourcesByType(ResourceTypeEnum.VFC.toString(), ResourceTypeEnum.VFC.toString());
 407
 408                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 409                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 410                 riCap.setUniqueId("123");
 411
 412                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 413
 414                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 415                                 capReqDefBeforeAssociate);
 416
 417                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
 418                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
 419                 assertEquals("Check response code ", 400, associateInstances.getErrorCode().intValue());
 420                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESOURCE_INSTANCE_BAD_REQUEST.name(),
 421                                 new ArrayList<String>(), associateInstances.getResponse());
 422
 423                 // "messageId": "SVC4116",
 424                 // "text": "Error: Invalid Content.",
 425                 // "variables": [
 426                 // "SoftCompRouter 1",
 427                 // "012f6dcd-bcdf-4d9b-87be-ff1442b95831.5d265453-0b6a-4453-8f3d-57a253b88432.softcomprouter1",
 428                 // "host"
 429         }
 430
 431         @Test
 432         public void associateCpToDeletedVfcTest() throws Exception {
 433                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VFC.toString());
 434
 435                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 436                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 437
 438                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 439
 440                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 441                                 capReqDefBeforeAssociate);
 442
 443                 RestResponse deleteResourceResponse = ResourceRestUtils.deleteResource(resourceDetailsCap.getUniqueId(),
 444                                 designerUser.getUserId());
 445                 ResourceRestUtils.checkDeleteResponse(deleteResourceResponse);
 446
 447                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
 448                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
 449                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
 450                 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
 451                                 resourceDetailsVF.getUniqueId()));
 452
 453         }
 454
 455         @Test
 456         public void associateCpToDeletedVlTest() throws Exception {
 457                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
 458
 459                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 460                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 461
 462                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 463
 464                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 465                                 capReqDefBeforeAssociate);
 466
 467                 RestResponse deleteResourceResponse = ResourceRestUtils.deleteResource(resourceDetailsCap.getUniqueId(),
 468                                 designerUser.getUserId());
 469                 ResourceRestUtils.checkDeleteResponse(deleteResourceResponse);
 470
 471                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
 472                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
 473                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
 474                 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
 475                                 resourceDetailsVF.getUniqueId()));
 476
 477         }
 478
 479         @Test
 480         public void associateCpToDeletedCpTest() throws Exception {
 481                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.CP.toString());
 482
 483                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 484                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 485
 486                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 487
 488                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 489                                 capReqDefBeforeAssociate);
 490
 491                 RestResponse deleteResourceResponse = ResourceRestUtils.deleteResource(resourceDetailsCap.getUniqueId(),
 492                                 designerUser.getUserId());
 493                 ResourceRestUtils.checkDeleteResponse(deleteResourceResponse);
 494
 495                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
 496                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
 497                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
 498                 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
 499                                 resourceDetailsVF.getUniqueId()));
 500
 501         }
 502
 503         // Error handling
 504         @Test
 505         public void associateCpToDeletedCpInstanceTest() throws Exception {
 506                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.CP.toString());
 507
 508                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 509                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 510
 511                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 512
 513                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 514                                 capReqDefBeforeAssociate);
 515
 516                 RestResponse deleteComponentInstance = ComponentInstanceRestUtils.deleteComponentInstance(designerUser,
 517                                 resourceDetailsVF.getUniqueId(), riReq.getUniqueId(), ComponentTypeEnum.RESOURCE);
 518                 ComponentInstanceRestUtils.checkDeleteResponse(deleteComponentInstance);
 519
 520                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
 521                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
 522                 assertEquals("Check response code ", 400, associateInstances.getErrorCode().intValue());
 523
 524                 // "messageId": "SVC4116",
 525                 // "text": "Error: Invalid Content.",
 526                 // "variables": [
 527                 // "7d6aca08-9321-4ea1-a781-c52c8214a30e.c0e63466-5283-44d8-adff-365c0885a6ba.softcomprouter1",
 528                 // "MyCompute 2",
 529                 // "host"
 530                 // ]
 531         }
 532
 533         // Error handling
 534         @Test
 535         public void associateVfcToDeletedVFCInstanceTest() throws Exception {
 536                 createTwoAtomicResourcesByType(ResourceTypeEnum.VFC.toString(), ResourceTypeEnum.VFC.toString());
 537
 538                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 539                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 540
 541                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 542
 543                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 544                                 capReqDefBeforeAssociate);
 545
 546                 RestResponse deleteComponentInstance = ComponentInstanceRestUtils.deleteComponentInstance(designerUser,
 547                                 resourceDetailsVF.getUniqueId(), riReq.getUniqueId(), ComponentTypeEnum.RESOURCE);
 548                 ComponentInstanceRestUtils.checkDeleteResponse(deleteComponentInstance);
 549
 550                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
 551                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
 552                 assertEquals("Check response code ", 400, associateInstances.getErrorCode().intValue());
 553
 554                 // "messageId": "SVC4116",
 555                 // "text": "Error: Invalid Content.",
 556                 // "variables": [
 557                 // "7d6aca08-9321-4ea1-a781-c52c8214a30e.c0e63466-5283-44d8-adff-365c0885a6ba.softcomprouter1",
 558                 // "MyCompute 2",
 559                 // "host"
 560                 // ]
 561         }
 562
 563         @Test
 564         public void associateWithDifferentOwnerOfVf() throws Exception {
 565                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
 566
 567                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 568                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 569
 570                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 571
 572                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 573                                 capReqDefBeforeAssociate);
 574
 575                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
 576                                 .getCapabilities();
 577                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
 578                                 .getRequirements();
 579
 580                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef,
 581                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER2), resourceDetailsVF.getUniqueId(),
 582                                 ComponentTypeEnum.RESOURCE);
 583                 assertEquals("Check response code ", 409, associateInstances.getErrorCode().intValue());
 584                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
 585                                 associateInstances.getResponse());
 586
 587                 CapReqDef capReqDef = getResourceReqCap();
 588
 589                 Map<String, List<CapabilityDefinition>> capabilitiesAfterAssociate = capReqDef.getCapabilities();
 590                 Map<String, List<RequirementDefinition>> requirementsAfterAssociate = capReqDef.getRequirements();
 591
 592                 assertTrue(capabilitiesAfterAssociate.equals(capabilitiesBeforeAssociate));
 593                 assertTrue(requirementsAfterAssociate.equals(requirementsBeforeAssociate));
 594         }
 595
 596         @Test
 597         public void associateWithTester() throws Exception {
 598                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
 599
 600                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 601                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 602
 603                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 604
 605                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 606                                 capReqDefBeforeAssociate);
 607
 608                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
 609                                 .getCapabilities();
 610                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
 611                                 .getRequirements();
 612
 613                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef,
 614                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), resourceDetailsVF.getUniqueId(),
 615                                 ComponentTypeEnum.RESOURCE);
 616                 assertEquals("Check response code ", 409, associateInstances.getErrorCode().intValue());
 617                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
 618                                 associateInstances.getResponse());
 619
 620                 CapReqDef capReqDef = getResourceReqCap();
 621
 622                 Map<String, List<CapabilityDefinition>> capabilitiesAfterAssociate = capReqDef.getCapabilities();
 623                 Map<String, List<RequirementDefinition>> requirementsAfterAssociate = capReqDef.getRequirements();
 624
 625                 assertTrue(capabilitiesAfterAssociate.equals(capabilitiesBeforeAssociate));
 626                 assertTrue(requirementsAfterAssociate.equals(requirementsBeforeAssociate));
 627         }
 628
 629         // Error handling
 630         @Test
 631         public void associateCpToVLIntoVFNotFound() throws Exception {
 632                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
 633
 634                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 635                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 636
 637                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 638
 639                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 640                                 capReqDefBeforeAssociate);
 641
 642                 String uidNotFound = "123";
 643                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
 644                                 uidNotFound, ComponentTypeEnum.RESOURCE);
 645                 assertEquals("Check response code ", 404, associateInstances.getErrorCode().intValue());
 646                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESOURCE_NOT_FOUND.name(),
 647                                 new ArrayList<String>(Arrays.asList("")), associateInstances.getResponse());
 648
 649                 // {"serviceException":{"messageId":"SVC4063","text":"Error: Requested
 650                 // '%1' resource was not found.","variables":[""]}}}
 651         }
 652
 653         // Error Handling
 654         @Test
 655         public void associateCpToVlWithMissingUid() throws Exception {
 656                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
 657
 658                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 659                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 660
 661                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 662
 663                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 664                                 capReqDefBeforeAssociate);
 665
 666                 requirementDef.setToNode("");
 667                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
 668                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
 669                 assertEquals("Check response code ", 400, associateInstances.getErrorCode().intValue());
 670                 // ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(),
 671                 // new ArrayList<String>(), associateInstances.getResponse());
 672
 673                 // "messageId": "SVC4116",
 674                 // "text": "Error: Invalid Content.",
 675                 // "variables": [
 676                 // "SoftCompRouter 1",
 677                 // "fd3a689b-fa1c-4105-933d-d1310e642f05.95bce626-ce73-413b-8c14-2388d1589d5c.softcomprouter1",
 678                 // "host"
 679                 // ]
 680         }
 681
 682         @Test
 683         public void associateInServiceWithUidOfVf() throws Exception {
 684                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
 685
 686                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 687                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 688
 689                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 690
 691                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 692                                 capReqDefBeforeAssociate);
 693
 694                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
 695                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.SERVICE);
 696                 assertEquals("Check response code ", 404, associateInstances.getErrorCode().intValue());
 697                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.SERVICE_NOT_FOUND.name(),
 698                                 new ArrayList<String>(Arrays.asList("")), associateInstances.getResponse());
 699         }
 700
 701         @Test
 702         public void associateCpToVl_DifferentOwners() throws Exception {
 703                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString(), designerUser,
 704                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER2));
 705
 706                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 707                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 708
 709                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 710
 711                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
 712                                 .getCapabilities();
 713                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
 714                                 .getRequirements();
 715
 716                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 717                                 capReqDefBeforeAssociate);
 718
 719                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
 720                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
 721                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
 722                 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
 723                                 resourceDetailsVF.getUniqueId()));
 724
 725                 CapReqDef capReqDef = getResourceReqCap();
 726
 727                 requirementsBeforeAssociate.remove("tosca.capabilities.Container");
 728                 assertTrue(capReqDef.getRequirements().equals(requirementsBeforeAssociate));
 729
 730                 List<CapabilityDefinition> list = capabilitiesBeforeAssociate.get("tosca.capabilities.Container");
 731                 for (CapabilityDefinition cap : list) {
 732                         cap.setMinOccurrences("0");
 733                 }
 734
 735                 Map<String, List<CapabilityDefinition>> capabilitiesAfterAssociate = capReqDef.getCapabilities();
 736                 assertTrue(capabilitiesAfterAssociate.equals(capabilitiesBeforeAssociate));
 737         }
 738
 739         @Test(enabled = false)
 740         public void associateToNotCheckedoutVf() throws Exception {
 741                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
 742
 743                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 744                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 745
 746                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 747                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
 748                                 .getCapabilities();
 749                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
 750                                 .getRequirements();
 751
 752                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 753                                 capReqDefBeforeAssociate);
 754
 755                 RestResponse changeResourceStateToCheckin = LifecycleRestUtils.changeResourceState(resourceDetailsVF,
 756                                 designerUser, LifeCycleStatesEnum.CHECKIN);
 757                 LifecycleRestUtils.checkSuccess(changeResourceStateToCheckin);
 758
 759                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
 760                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
 761                 assertEquals("Check response code ", 409, associateInstances.getErrorCode().intValue());
 762                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
 763                                 associateInstances.getResponse());
 764
 765                 CapReqDef capReqDef = getResourceReqCap();
 766                 assertTrue(capReqDef.getRequirements().equals(requirementsBeforeAssociate));
 767                 assertTrue(capReqDef.getCapabilities().equals(capabilitiesBeforeAssociate));
 768
 769                 String firstUniqueId = resourceDetailsVF.getUniqueId();
 770
 771                 // checkout
 772
 773                 RestResponse changeResourceStateToCheckout = LifecycleRestUtils.changeResourceState(resourceDetailsVF,
 774                                 designerUser, LifeCycleStatesEnum.CHECKOUT);
 775                 LifecycleRestUtils.checkSuccess(changeResourceStateToCheckout);
 776                 String secondUniqueId = resourceDetailsVF.getUniqueId();
 777
 778                 CapReqDef capReqDefAfterFirstCheckout = getResourceReqCap();
 779                 Map<String, List<CapabilityDefinition>> capabilitiesAfterFirstCheckout = capReqDefAfterFirstCheckout
 780                                 .getCapabilities();
 781                 Map<String, List<RequirementDefinition>> requirementsAfterFirstCheckout = capReqDefAfterFirstCheckout
 782                                 .getRequirements();
 783
 784                 requirementDef = setUidsOfInstancesAfterLifecycleStateChange(riReq, riCap, capReqDefBeforeAssociate);
 785
 786                 RestResponse firstAssociateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef,
 787                                 designerUser, resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
 788                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, firstAssociateInstances.getErrorCode().intValue());
 789                 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
 790                                 resourceDetailsVF.getUniqueId()));
 791
 792                 CapReqDef capReqDefAfterFirstAssociate = getResourceReqCap();
 793                 Map<String, List<CapabilityDefinition>> capabilitiesAfterFirstAssociate = capReqDefAfterFirstAssociate
 794                                 .getCapabilities();
 795                 Map<String, List<RequirementDefinition>> requirementsAfterFirstAssociate = capReqDefAfterFirstAssociate
 796                                 .getRequirements();
 797
 798                 requirementsAfterFirstCheckout.remove("tosca.capabilities.Container");
 799                 assertTrue(requirementsAfterFirstAssociate.equals(requirementsAfterFirstCheckout));
 800                 assertTrue(capabilitiesAfterFirstAssociate.equals(capabilitiesAfterFirstCheckout));
 801
 802                 resourceDetailsVF.setUniqueId(firstUniqueId);
 803                 CapReqDef capReqDefOfFirstVersion = getResourceReqCap();
 804                 Map<String, List<CapabilityDefinition>> capabilitiesOfFirstVersion = capReqDefOfFirstVersion.getCapabilities();
 805                 Map<String, List<RequirementDefinition>> requirementsOfFirstVersion = capReqDefOfFirstVersion.getRequirements();
 806
 807                 assertTrue(getComponentInstancesRelations(resourceDetailsVF.getUniqueId()).isEmpty());
 808                 assertTrue(requirementsBeforeAssociate.equals(requirementsOfFirstVersion));
 809                 assertTrue(capabilitiesBeforeAssociate.equals(capabilitiesOfFirstVersion));
 810
 811                 // checkin-checkout
 812                 resourceDetailsVF.setUniqueId(secondUniqueId);
 813                 RestResponse changeResourceStateToCheckin2 = LifecycleRestUtils.changeResourceState(resourceDetailsVF,
 814                                 designerUser, LifeCycleStatesEnum.CHECKIN);
 815                 LifecycleRestUtils.checkSuccess(changeResourceStateToCheckin2);
 816                 RestResponse changeResourceStateToCheckout2 = LifecycleRestUtils.changeResourceState(resourceDetailsVF,
 817                                 designerUser, LifeCycleStatesEnum.CHECKOUT);
 818                 LifecycleRestUtils.checkSuccess(changeResourceStateToCheckout2);
 819
 820                 List<RequirementCapabilityRelDef> componentInstancesRelations = getComponentInstancesRelations(
 821                                 resourceDetailsVF.getUniqueId());
 822                 assertFalse(componentInstancesRelations.isEmpty());
 823                 assertEquals(1, componentInstancesRelations.size());
 824                 List<ComponentInstance> componentInstancesList = getComponentInstancesList(resourceDetailsVF.getUniqueId());
 825                 for (ComponentInstance comp : componentInstancesList) {
 826                         String instanceUid = comp.getUniqueId();
 827                         assertTrue(checkNodesInRelations(instanceUid, componentInstancesRelations.get(0)));
 828                 }
 829                 assertEquals(2, componentInstancesList.size());
 830
 831         }
 832
 833         private RequirementCapabilityRelDef setUidsOfInstancesAfterLifecycleStateChange(ComponentInstance riReq,
 834                         ComponentInstance riCap, CapReqDef capReqDefBeforeAssociate)
 835                         throws ClientProtocolException, IOException, Exception {
 836                 RequirementCapabilityRelDef requirementDef;
 837                 // RestResponse getResourceResponse =
 838                 // ResourceRestUtils.getResource(resourceDetailsVF.getUniqueId());
 839                 // Resource resource_0_2 =
 840                 // ResponseParser.parseToObjectUsingMapper(getResourceResponse.getResponse(),
 841                 // Resource.class);
 842                 // List<ComponentInstance> componentInstances =
 843                 // resource_0_2.getComponentInstances();
 844                 List<ComponentInstance> componentInstances = getComponentInstancesList(resourceDetailsVF.getUniqueId());
 845
 846                 for (ComponentInstance comp : componentInstances) {
 847                         if (comp.getName().equals(riReq.getName())) {
 848                                 riReq.setUniqueId(comp.getUniqueId());
 849                         } else if (comp.getName().equals(riCap.getName())) {
 850                                 riCap.setUniqueId(comp.getUniqueId());
 851                         }
 852                 }
 853                 requirementDef = setRelationshipBetweenInstances(riReq, riCap, capReqDefBeforeAssociate);
 854                 return requirementDef;
 855         }
 856
 857         private boolean checkNodesInRelations(String instanceUid, RequirementCapabilityRelDef relation) {
 858                 if (relation.getToNode().equals(instanceUid)) {
 859                         return true;
 860                 } else if (relation.getFromNode().equals(instanceUid)) {
 861                         return true;
 862                 } else {
 863                         return false;
 864                 }
 865         }
 866
 867         @Test
 868         public void associateOneOfTwoCPsToVl_ThenDiscocciate() throws Exception {
 869                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
 870                 ResourceReqDetails secondResourceDetailsReq = new ResourceReqDetails(resourceDetailsReq, "0.1");
 871                 secondResourceDetailsReq.setName("secondCP");
 872                 secondResourceDetailsReq.setTags(Arrays.asList(secondResourceDetailsReq.getName()));
 873                 createAtomicResource(secondResourceDetailsReq, designerUser);
 874
 875                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 876                 ComponentInstance riReq2 = createComponentInstance(secondResourceDetailsReq);
 877                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 878
 879                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 880
 881                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
 882                                 .getCapabilities();
 883                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
 884                                 .getRequirements();
 885
 886                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 887                                 capReqDefBeforeAssociate);
 888
 889                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
 890                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
 891                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
 892                 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
 893                                 resourceDetailsVF.getUniqueId()));
 894
 895                 CapReqDef capReqDef = getResourceReqCap();
 896
 897                 List<RequirementDefinition> expectedList = requirementsBeforeAssociate.get("tosca.capabilities.Container");
 898                 for (RequirementDefinition req : expectedList) {
 899                         if (req.getOwnerName().equals(riReq2.getName())) {
 900                                 expectedList = new ArrayList<RequirementDefinition>(Arrays.asList(req));
 901                                 break;
 902                         }
 903                 }
 904                 requirementsBeforeAssociate.put("tosca.capabilities.Container", expectedList);
 905                 assertTrue(capReqDef.getRequirements().equals(requirementsBeforeAssociate));
 906
 907                 List<CapabilityDefinition> list = capabilitiesBeforeAssociate.get("tosca.capabilities.Container");
 908                 for (CapabilityDefinition cap : list) {
 909                         cap.setMinOccurrences("0");
 910                 }
 911
 912                 Map<String, List<CapabilityDefinition>> capabilitiesAfterAssociate = capReqDef.getCapabilities();
 913                 assertTrue(capabilitiesAfterAssociate.equals(capabilitiesBeforeAssociate));
 914
 915                 // second relationship
 916
 917                 RequirementCapabilityRelDef secondRequirementDef = setRelationshipBetweenInstances(riReq2, riCap,
 918                                 capReqDefBeforeAssociate);
 919                 RestResponse secondAssociateInstances = ComponentInstanceRestUtils.associateInstances(secondRequirementDef,
 920                                 designerUser, resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
 921                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, secondAssociateInstances.getErrorCode().intValue());
 922                 assertTrue(checkRealtionship(secondRequirementDef.getFromNode(), secondRequirementDef.getToNode(),
 923                                 resourceDetailsVF.getUniqueId()));
 924
 925                 CapReqDef capReqDefAfterSecondAssociation = getResourceReqCap();
 926
 927                 requirementsBeforeAssociate.remove("tosca.capabilities.Container");
 928                 assertTrue(capReqDefAfterSecondAssociation.getRequirements().equals(requirementsBeforeAssociate));
 929
 930                 Map<String, List<CapabilityDefinition>> capabilitiesAfterSecondAssociate = capReqDefAfterSecondAssociation
 931                                 .getCapabilities();
 932                 assertTrue(capabilitiesAfterSecondAssociate.equals(capabilitiesBeforeAssociate));
 933
 934                 // dissociate
 935
 936                 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(secondRequirementDef,
 937                                 designerUser, resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
 938                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, dissociateInstances.getErrorCode().intValue());
 939                 assertTrue(getComponentInstancesRelations(resourceDetailsVF.getUniqueId()).isEmpty());
 940
 941                 CapReqDef capReqDefAfterDissociation = getResourceReqCap();
 942                 Map<String, List<CapabilityDefinition>> capabilitiesAfterDissociate = capReqDefAfterDissociation
 943                                 .getCapabilities();
 944                 Map<String, List<RequirementDefinition>> requirementsAfterDissociate = capReqDefAfterDissociation
 945                                 .getRequirements();
 946
 947                 assertTrue(capabilitiesAfterDissociate.equals(capReqDef.getCapabilities()));
 948                 requirementsBeforeAssociate.put("tosca.capabilities.Container", expectedList);
 949                 assertTrue(requirementsAfterDissociate.equals(requirementsBeforeAssociate));
 950         }
 951
 952         @Test
 953         public void associateNotCompitableCapAndReq() throws Exception {
 954                 resourceDetailsReq = ElementFactory.getDefaultResourceByType("Database", NormativeTypesEnum.DATABASE,
 955                                 ResourceCategoryEnum.NETWORK_L2_3_ROUTERS, designerUser.getUserId(), ResourceTypeEnum.CP.toString()); // resourceType
 956                                                                                                                                                                                                                                                 // =
 957                                                                                                                                                                                                                                                 // VFC
 958                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
 959
 960                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 961                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 962
 963                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 964
 965                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
 966                                 .getCapabilities();
 967                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
 968                                 .getRequirements();
 969
 970                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
 971                                 capReqDefBeforeAssociate);
 972                 assertTrue(requirementDef.getRelationships().size() == 1);
 973                 String requirement = requirementDef.getRelationships().get(0).getRelation().getRequirement();
 974                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
 975                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
 976                 assertEquals("Check response code ", 404, associateInstances.getErrorCode().intValue());
 977                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESOURCE_INSTANCE_MATCH_NOT_FOUND.name(),
 978                                 new ArrayList<String>(Arrays.asList(riReq.getName(), riCap.getName(), requirement)),
 979                                 associateInstances.getResponse());
 980
 981                 CapReqDef capReqDef = getResourceReqCap();
 982
 983                 Map<String, List<CapabilityDefinition>> capabilitiesAfterAssociate = capReqDef.getCapabilities();
 984                 Map<String, List<RequirementDefinition>> requirementsAfterAssociate = capReqDef.getRequirements();
 985
 986                 assertTrue(capabilitiesAfterAssociate.equals(capabilitiesBeforeAssociate));
 987                 assertTrue(requirementsAfterAssociate.equals(requirementsBeforeAssociate));
 988
 989         }
 990
 991         @Test
 992         public void disassociateCpAndCpTest() throws Exception {
 993                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.CP.toString());
 994
 995                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
 996                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
 997
 998                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
 999
1000                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1001                                 capReqDefBeforeAssociate);
1002                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1003                                 .getCapabilities();
1004                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1005                                 .getRequirements();
1006
1007                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
1008                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1009                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
1010                 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
1011                                 resourceDetailsVF.getUniqueId()));
1012
1013                 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef, designerUser,
1014                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1015                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, dissociateInstances.getErrorCode().intValue());
1016                 assertTrue(getComponentInstancesRelations(resourceDetailsVF.getUniqueId()).isEmpty());
1017
1018                 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1019
1020                 List<RequirementDefinition> listOfRequierments = capReqDefAfterDissociate.getRequirements()
1021                                 .get("tosca.capabilities.Container");
1022                 assertEquals("Check requirement", 1, listOfRequierments.size());
1023                 assertTrue(capReqDefAfterDissociate.getRequirements().equals(requirementsBeforeAssociate));
1024                 assertTrue(capReqDefAfterDissociate.getCapabilities().equals(capabilitiesBeforeAssociate));
1025         }
1026
1027         @Test
1028         public void disassociateCpAndVfcTest() throws Exception {
1029                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VFC.toString());
1030
1031                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1032                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1033
1034                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1035
1036                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1037                                 capReqDefBeforeAssociate);
1038                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1039                                 .getCapabilities();
1040                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1041                                 .getRequirements();
1042
1043                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
1044                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1045                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
1046                 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
1047                                 resourceDetailsVF.getUniqueId()));
1048
1049                 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef, designerUser,
1050                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1051                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, dissociateInstances.getErrorCode().intValue());
1052                 assertTrue(getComponentInstancesRelations(resourceDetailsVF.getUniqueId()).isEmpty());
1053
1054                 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1055
1056                 List<RequirementDefinition> listOfRequierments = capReqDefAfterDissociate.getRequirements()
1057                                 .get("tosca.capabilities.Container");
1058                 assertEquals("Check requirement", 1, listOfRequierments.size());
1059                 assertTrue(capReqDefAfterDissociate.getRequirements().equals(requirementsBeforeAssociate));
1060                 assertTrue(capReqDefAfterDissociate.getCapabilities().equals(capabilitiesBeforeAssociate));
1061         }
1062
1063         @Test
1064         public void disassociateCpAndVLTest() throws Exception {
1065                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
1066
1067                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1068                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1069
1070                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1071
1072                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1073                                 capReqDefBeforeAssociate);
1074                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1075                                 .getCapabilities();
1076                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1077                                 .getRequirements();
1078
1079                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
1080                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1081                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
1082                 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
1083                                 resourceDetailsVF.getUniqueId()));
1084
1085                 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef, designerUser,
1086                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1087                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, dissociateInstances.getErrorCode().intValue());
1088                 assertTrue(getComponentInstancesRelations(resourceDetailsVF.getUniqueId()).isEmpty());
1089
1090                 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1091
1092                 List<RequirementDefinition> listOfRequierments = capReqDefAfterDissociate.getRequirements()
1093                                 .get("tosca.capabilities.Container");
1094                 assertEquals("Check requirement", 1, listOfRequierments.size());
1095                 assertTrue(capReqDefAfterDissociate.getRequirements().equals(requirementsBeforeAssociate));
1096                 assertTrue(capReqDefAfterDissociate.getCapabilities().equals(capabilitiesBeforeAssociate));
1097         }
1098
1099         // Error handliing
1100         // in the error should we get the unique id of instances instead of names
1101         @Test
1102         public void disassociateNotFoundAssociation() throws Exception {
1103                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
1104
1105                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1106                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1107
1108                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1109
1110                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1111                                 capReqDefBeforeAssociate);
1112                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1113                                 .getCapabilities();
1114                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1115                                 .getRequirements();
1116                 String requirementName = requirementDef.getRelationships().get(0).getRelation().getRequirement();
1117
1118                 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef, designerUser,
1119                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1120                 assertEquals("Check response code ", 404, dissociateInstances.getErrorCode().intValue());
1121                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESOURCE_INSTANCE_RELATION_NOT_FOUND.name(),
1122                                 new ArrayList<String>(Arrays.asList(riReq.getName(), riCap.getName(), requirementName)),
1123                                 dissociateInstances.getResponse());
1124
1125                 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1126
1127                 List<RequirementDefinition> listOfRequierments = capReqDefAfterDissociate.getRequirements()
1128                                 .get("tosca.capabilities.Container");
1129                 assertEquals("Check requirement", 1, listOfRequierments.size());
1130                 assertTrue(capReqDefAfterDissociate.getRequirements().equals(requirementsBeforeAssociate));
1131                 assertTrue(capReqDefAfterDissociate.getCapabilities().equals(capabilitiesBeforeAssociate));
1132         }
1133
1134         // Error handliing
1135         @Test
1136         public void disassociateRelationInVfNotFound() throws Exception {
1137                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
1138
1139                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1140                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1141
1142                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1143
1144                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1145                                 capReqDefBeforeAssociate);
1146
1147                 String uidNotFound = "123";
1148                 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef, designerUser,
1149                                 uidNotFound, ComponentTypeEnum.RESOURCE);
1150                 assertEquals("Check response code ", 404, dissociateInstances.getErrorCode().intValue());
1151                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESOURCE_NOT_FOUND.name(),
1152                                 new ArrayList<String>(Arrays.asList(uidNotFound)), dissociateInstances.getResponse());
1153
1154                 // "serviceException": {
1155                 // "messageId": "SVC4063",
1156                 // "text": "Error: Requested \u0027%1\u0027 resource was not found.",
1157                 // "variables": [
1158                 // ""
1159                 // ]
1160         }
1161
1162         @Test
1163         public void disassociateWithDifferentDesigner() throws Exception {
1164                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
1165
1166                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1167                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1168
1169                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1170
1171                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1172                                 capReqDefBeforeAssociate);
1173                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1174                                 .getCapabilities();
1175                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1176                                 .getRequirements();
1177
1178                 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef,
1179                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER2), resourceDetailsVF.getUniqueId(),
1180                                 ComponentTypeEnum.RESOURCE);
1181                 assertEquals("Check response code ", 409, dissociateInstances.getErrorCode().intValue());
1182                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
1183                                 dissociateInstances.getResponse());
1184
1185                 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1186
1187                 List<RequirementDefinition> listOfRequierments = capReqDefAfterDissociate.getRequirements()
1188                                 .get("tosca.capabilities.Container");
1189                 assertEquals("Check requirement", 1, listOfRequierments.size());
1190                 assertTrue(capReqDefAfterDissociate.getRequirements().equals(requirementsBeforeAssociate));
1191                 assertTrue(capReqDefAfterDissociate.getCapabilities().equals(capabilitiesBeforeAssociate));
1192
1193         }
1194
1195         @Test
1196         public void disassociateWithTester() throws Exception {
1197                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
1198
1199                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1200                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1201
1202                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1203
1204                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1205                                 capReqDefBeforeAssociate);
1206                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1207                                 .getCapabilities();
1208                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1209                                 .getRequirements();
1210
1211                 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef,
1212                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), resourceDetailsVF.getUniqueId(),
1213                                 ComponentTypeEnum.RESOURCE);
1214                 assertEquals("Check response code ", 409, dissociateInstances.getErrorCode().intValue());
1215                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
1216                                 dissociateInstances.getResponse());
1217
1218                 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1219
1220                 List<RequirementDefinition> listOfRequierments = capReqDefAfterDissociate.getRequirements()
1221                                 .get("tosca.capabilities.Container");
1222                 assertNotNull("Requierment is null after disassociate with tester", listOfRequierments);
1223                 assertEquals("Check requirement", 1, listOfRequierments.size());
1224                 assertTrue(capReqDefAfterDissociate.getRequirements().equals(requirementsBeforeAssociate));
1225                 assertTrue(capReqDefAfterDissociate.getCapabilities().equals(capabilitiesBeforeAssociate));
1226         }
1227
1228         @Test
1229         public void disassociateServiceWithUidOfVF() throws Exception {
1230                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VFC.toString());
1231
1232                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1233                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1234
1235                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1236
1237                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1238                                 capReqDefBeforeAssociate);
1239
1240                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
1241                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1242                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
1243                 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
1244                                 resourceDetailsVF.getUniqueId()));
1245
1246                 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef, designerUser,
1247                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.SERVICE);
1248                 assertEquals("Check response code ", 404, dissociateInstances.getErrorCode().intValue());
1249                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.SERVICE_NOT_FOUND.name(),
1250                                 new ArrayList<String>(Arrays.asList("")), dissociateInstances.getResponse());
1251
1252                 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1253
1254                 List<RequirementDefinition> listOfRequierments = capReqDefAfterDissociate.getRequirements()
1255                                 .get("tosca.capabilities.Container");
1256                 assertTrue(listOfRequierments == null);
1257                 assertTrue(getComponentInstancesRelations(resourceDetailsVF.getUniqueId()).size() != 0);
1258         }
1259
1260         @Test
1261         public void disassociateWithEmptyVfUid() throws Exception {
1262                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
1263
1264                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1265                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1266
1267                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1268
1269                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1270                                 capReqDefBeforeAssociate);
1271                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1272                                 .getCapabilities();
1273                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1274                                 .getRequirements();
1275
1276                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
1277                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1278                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
1279                 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
1280                                 resourceDetailsVF.getUniqueId()));
1281
1282                 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef, designerUser,
1283                                 "", ComponentTypeEnum.RESOURCE);
1284                 assertEquals("Check response code ", 404, dissociateInstances.getErrorCode().intValue());
1285
1286                 CapReqDef capReqDef = getResourceReqCap();
1287
1288                 requirementsBeforeAssociate.remove("tosca.capabilities.Container");
1289                 assertTrue(capReqDef.getRequirements().equals(requirementsBeforeAssociate));
1290
1291                 List<CapabilityDefinition> list = capabilitiesBeforeAssociate.get("tosca.capabilities.Container");
1292                 for (CapabilityDefinition cap : list) {
1293                         cap.setMinOccurrences("0");
1294                 }
1295
1296                 Map<String, List<CapabilityDefinition>> capabilitiesAfterAssociate = capReqDef.getCapabilities();
1297                 assertTrue(capabilitiesAfterAssociate.equals(capabilitiesBeforeAssociate));
1298         }
1299
1300         @Test
1301         public void disassociateOneComponentDeleted() throws Exception {
1302                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
1303
1304                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1305                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1306
1307                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1308
1309                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1310                                 capReqDefBeforeAssociate);
1311                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1312                                 .getCapabilities();
1313                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1314                                 .getRequirements();
1315
1316                 ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
1317                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1318
1319                 RestResponse deleteResourceResponse = ResourceRestUtils.deleteResource(resourceDetailsCap.getUniqueId(),
1320                                 designerUser.getUserId());
1321                 ResourceRestUtils.checkDeleteResponse(deleteResourceResponse);
1322
1323                 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef, designerUser,
1324                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1325                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, dissociateInstances.getErrorCode().intValue());
1326                 assertTrue(getComponentInstancesRelations(resourceDetailsVF.getUniqueId()).isEmpty());
1327
1328                 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1329
1330                 List<RequirementDefinition> listOfRequierments = capReqDefAfterDissociate.getRequirements()
1331                                 .get("tosca.capabilities.Container");
1332                 assertEquals("Check requirement", 1, listOfRequierments.size());
1333                 assertTrue(capReqDefAfterDissociate.getRequirements().equals(requirementsBeforeAssociate));
1334                 assertTrue(capReqDefAfterDissociate.getCapabilities().equals(capabilitiesBeforeAssociate));
1335         }
1336
1337         @Test
1338         public void disassociateNotCheckedoutVf() throws Exception {
1339                 createTwoAtomicResourcesByType(ResourceTypeEnum.CP.toString(), ResourceTypeEnum.VL.toString());
1340
1341                 ComponentInstance riReq = createComponentInstance(resourceDetailsReq);
1342                 ComponentInstance riCap = createComponentInstance(resourceDetailsCap);
1343
1344                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap();
1345                 Map<String, List<CapabilityDefinition>> capabilitiesBeforeAssociate = capReqDefBeforeAssociate
1346                                 .getCapabilities();
1347                 Map<String, List<RequirementDefinition>> requirementsBeforeAssociate = capReqDefBeforeAssociate
1348                                 .getRequirements();
1349
1350                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(riReq, riCap,
1351                                 capReqDefBeforeAssociate);
1352
1353                 RestResponse changeResourceStateToCheckin = LifecycleRestUtils.changeResourceState(resourceDetailsVF,
1354                                 designerUser, LifeCycleStatesEnum.CHECKIN);
1355                 LifecycleRestUtils.checkSuccess(changeResourceStateToCheckin);
1356
1357                 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef, designerUser,
1358                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1359                 assertEquals("Check response code ", 409, dissociateInstances.getErrorCode().intValue());
1360                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
1361                                 dissociateInstances.getResponse());
1362
1363                 CapReqDef capReqDefAfterDissociate = getResourceReqCap();
1364                 assertTrue(capReqDefAfterDissociate.getRequirements().equals(requirementsBeforeAssociate));
1365                 assertTrue(capReqDefAfterDissociate.getCapabilities().equals(capabilitiesBeforeAssociate));
1366
1367                 RestResponse changeResourceStateToCheckout = LifecycleRestUtils.changeResourceState(resourceDetailsVF,
1368                                 designerUser, LifeCycleStatesEnum.CHECKOUT);
1369                 LifecycleRestUtils.checkSuccess(changeResourceStateToCheckout);
1370
1371                 requirementDef = setUidsOfInstancesAfterLifecycleStateChange(riReq, riCap, capReqDefBeforeAssociate);
1372
1373                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, designerUser,
1374                                 resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1375                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
1376                 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
1377                                 resourceDetailsVF.getUniqueId()));
1378
1379                 RestResponse secondDisociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef,
1380                                 designerUser, resourceDetailsVF.getUniqueId(), ComponentTypeEnum.RESOURCE);
1381                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, secondDisociateInstances.getErrorCode().intValue());
1382                 assertTrue(getComponentInstancesRelations(resourceDetailsVF.getUniqueId()).isEmpty());
1383
1384                 RestResponse changeResourceStateToCheckout2 = LifecycleRestUtils.changeResourceState(resourceDetailsVF,
1385                                 designerUser, LifeCycleStatesEnum.CHECKIN);
1386                 LifecycleRestUtils.checkSuccess(changeResourceStateToCheckout2);
1387                 RestResponse changeResourceStateToCheckout3 = LifecycleRestUtils.changeResourceState(resourceDetailsVF,
1388                                 designerUser, LifeCycleStatesEnum.CHECKOUT);
1389                 LifecycleRestUtils.checkSuccess(changeResourceStateToCheckout3);
1390
1391                 assertTrue(getComponentInstancesRelations(resourceDetailsVF.getUniqueId()).isEmpty());
1392
1393         }
1394
1395 }