gerrit.onap Code Review - sdc.git/blob

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