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

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