test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/service/ReqCapOccurrencesTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.ci.tests.execute.service;
  22
  23 import org.apache.http.client.ClientProtocolException;
  24 import org.junit.rules.TestName;
  25 import org.openecomp.sdc.be.dao.api.ActionStatus;
  26 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  27 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  28 import org.openecomp.sdc.be.model.*;
  29 import org.openecomp.sdc.ci.tests.api.ComponentInstanceBaseTest;
  30 import org.openecomp.sdc.ci.tests.datatypes.ImportReqDetails;
  31 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  32 import org.openecomp.sdc.ci.tests.datatypes.enums.*;
  33 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  34 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  35 import org.openecomp.sdc.ci.tests.utils.general.ImportUtils;
  36 import org.openecomp.sdc.ci.tests.utils.rest.*;
  37 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  38 import org.testng.annotations.BeforeMethod;
  39 import org.testng.annotations.Test;
  40
  41 import java.io.File;
  42 import java.io.IOException;
  43 import java.util.ArrayList;
  44 import java.util.HashMap;
  45 import java.util.LinkedHashMap;
  46 import java.util.List;
  47
  48 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_SUCCESS;
  49 import static org.testng.AssertJUnit.*;
  50
  51 public class ReqCapOccurrencesTest extends ComponentInstanceBaseTest {
  52
  53         private ImportReqDetails importReqDetails1; // atomic resource
  54         private ImportReqDetails importReqDetails2;
  55         private ImportReqDetails importReqDetails3;
  56         private ImportReqDetails importReqDetails4;
  57         private Resource resourceVFC1;
  58         private Resource resourceVFC2;
  59         private Resource resourceVFC3;
  60         private Resource resourceVFC4;
  61         private ResourceReqDetails resourceDetailsVF100;
  62         private ResourceReqDetails resourceDetailsVF200;
  63         private Resource resourceVF100;
  64         private Resource resourceVF200;
  65         protected String testResourcesPath;
  66
  67         protected final String importYmlWithReq11 = "softwareComponentReq11.yml";
  68         protected final String importYmlWithReq12 = "softwareComponentReq12.yml";
  69         protected final String importYmlWithCap11 = "computeCap11.yml";
  70         protected final String importYmlWithCap1Unbounded = "computeCap1UNBOUNDED.yml";
  71         protected final String capabilitiesAndRequirementsType = "tosca.capabilities.Container";
  72
  73         public ReqCapOccurrencesTest() {
  74                 super(new TestName(), ReqCapOccurrencesTest.class.getSimpleName());
  75         }
  76
  77         @BeforeMethod
  78         public void before() throws Exception {
  79                 // Do not use call init() from ComponentInstanceBaseTest
  80                 expectedContainerCapabilities = new LinkedHashMap<String, List<CapabilityDefinition>>();
  81                 expectedContainerRequirements = new LinkedHashMap<String, List<RequirementDefinition>>();
  82                 removedRequirements = new HashMap<>();
  83                 expectedContInstReqCap = new HashMap<>();
  84
  85                 RestResponse importResourceResponse;
  86                 sdncDesignerDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
  87                 sdncAdminDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
  88                 // import yml file location
  89                 String sourceDir = config.getResourceConfigDir();
  90                 final String workDir = "importToscaResourceByCreateUrl";
  91                 testResourcesPath = sourceDir + File.separator + workDir;
  92                 ///// Create atomic resources /////////////////////////
  93                 // import VFC1 with Requirements : MIN=1 MAX=2
  94                 ///// (tosca.capabilities.Container)
  95                 importReqDetails1 = ElementFactory.getDefaultImportResource("VFC1");
  96                 importResourceResponse = importedResource(importReqDetails1, importYmlWithReq12);
  97                 // resourceVFC1 =
  98                 // ResponseParser.convertResourceResponseToJavaObject(importResourceResponse.getResponse());
  99                 RestResponse restResponse = LifecycleRestUtils.changeResourceState(importReqDetails1, sdncDesignerDetails,
 100                                 LifeCycleStatesEnum.CHECKIN);
 101                 resourceVFC1 = ResponseParser.convertResourceResponseToJavaObject(restResponse.getResponse());
 102                 // import VFC2 with Capabilities : MIN 1 MAX UNBOUNDED
 103                 // (tosca.capabilities.Container)
 104                 importReqDetails2 = ElementFactory.getDefaultImportResource("VFC2");
 105                 importResourceResponse = importedResource(importReqDetails2, importYmlWithCap1Unbounded);
 106                 // resourceVFC2 =
 107                 // ResponseParser.convertResourceResponseToJavaObject(importResourceResponse.getResponse());
 108                 restResponse = LifecycleRestUtils.changeResourceState(importReqDetails2, sdncDesignerDetails,
 109                                 LifeCycleStatesEnum.CHECKIN);
 110                 resourceVFC2 = ResponseParser.convertResourceResponseToJavaObject(restResponse.getResponse());
 111                 // import VFC3 with Capabilities : MIN 1 MAX 1
 112                 // (tosca.capabilities.Container)
 113                 importReqDetails3 = ElementFactory.getDefaultImportResource("VFC3");
 114                 importResourceResponse = importedResource(importReqDetails3, importYmlWithCap11);
 115                 // resourceVFC3 =
 116                 // ResponseParser.convertResourceResponseToJavaObject(importResourceResponse.getResponse());
 117                 restResponse = LifecycleRestUtils.changeResourceState(importReqDetails3, sdncDesignerDetails,
 118                                 LifeCycleStatesEnum.CHECKIN);
 119                 resourceVFC3 = ResponseParser.convertResourceResponseToJavaObject(restResponse.getResponse());
 120                 // import VFC4 with Requirements : MIN 1 MAX 1
 121                 // (tosca.capabilities.Container)
 122                 importReqDetails4 = ElementFactory.getDefaultImportResource("VFC4");
 123                 importResourceResponse = importedResource(importReqDetails4, importYmlWithReq11);
 124                 // resourceVFC4 =
 125                 // ResponseParser.convertResourceResponseToJavaObject(importResourceResponse.getResponse());
 126                 restResponse = LifecycleRestUtils.changeResourceState(importReqDetails4, sdncDesignerDetails,
 127                                 LifeCycleStatesEnum.CHECKIN);
 128                 resourceVFC4 = ResponseParser.convertResourceResponseToJavaObject(restResponse.getResponse());
 129
 130                 // create VF100
 131                 resourceDetailsVF100 = ElementFactory.getDefaultResourceByType("VF1000", NormativeTypesEnum.ROOT,
 132                                 ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, sdncDesignerDetails.getUserId(),
 133                                 ResourceTypeEnum.VF.toString());
 134                 RestResponse createResourceVF100 = ResourceRestUtils.createResource(resourceDetailsVF100, sdncDesignerDetails);
 135                 ResourceRestUtils.checkCreateResponse(createResourceVF100);
 136                 // create VF200
 137                 resourceDetailsVF200 = ElementFactory.getDefaultResourceByType("VF2000", NormativeTypesEnum.ROOT,
 138                                 ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, sdncDesignerDetails.getUserId(),
 139                                 ResourceTypeEnum.VF.toString());
 140                 RestResponse createResourceVF200 = ResourceRestUtils.createResource(resourceDetailsVF200, sdncDesignerDetails);
 141                 ResourceRestUtils.checkCreateResponse(createResourceVF200);
 142                 // Create Service
 143                 serviceDetails_01 = ElementFactory.getDefaultService("newtestservice1", ServiceCategoriesEnum.MOBILITY,
 144                                 sdncDesignerDetails.getUserId(), ServiceInstantiationType.A_LA_CARTE.getValue());
 145                 RestResponse createServiceRestResponse = ServiceRestUtils.createService(serviceDetails_01, sdncDesignerDetails);
 146                 ResourceRestUtils.checkCreateResponse(createServiceRestResponse);
 147
 148         }
 149
 150         // US628514 Capability/Requirement "Occurrences" attribute in CREATE/DELETE
 151         // Relation APIs
 152         // Container = SERVICE , Container instance = VF
 153         @Test
 154         public void capAndReqOccurrencesInServiceAndHisInstancesNoAssociation() throws Exception, Exception {
 155                 RestResponse getResourseRestResponse;
 156                 // Add instance of VFC1 (Req MIN=1 MAX=2) to VF1000
 157                 ComponentInstance componentInstanceReq = createComponentInstance(importReqDetails1, sdncDesignerDetails,
 158                                 resourceDetailsVF100);
 159                 assertNotNull(componentInstanceReq);
 160                 getResourseRestResponse = ResourceRestUtils.getResource(sdncDesignerDetails,
 161                                 resourceDetailsVF100.getUniqueId());
 162                 resourceVF100 = ResponseParser.parseToObjectUsingMapper(getResourseRestResponse.getResponse(), Resource.class);
 163                 // Add instance of VFC21 (Cap MIN=1 MAX=UNBOUNDED) to VF2000
 164                 ComponentInstance componentInstanceCap = createComponentInstance(importReqDetails2, sdncDesignerDetails,
 165                                 resourceDetailsVF200);
 166                 assertNotNull(componentInstanceCap);
 167                 getResourseRestResponse = ResourceRestUtils.getResource(sdncDesignerDetails,
 168                                 resourceDetailsVF200.getUniqueId());
 169                 resourceVF200 = ResponseParser.parseToObjectUsingMapper(getResourseRestResponse.getResponse(), Resource.class);
 170                 // Check-In both VFs
 171                 RestResponse restResponse = LifecycleRestUtils.changeResourceState(resourceDetailsVF100, sdncDesignerDetails,
 172                                 LifeCycleStatesEnum.CHECKIN);
 173                 ResourceRestUtils.checkSuccess(restResponse);
 174                 restResponse = LifecycleRestUtils.changeResourceState(resourceDetailsVF200, sdncDesignerDetails,
 175                                 LifeCycleStatesEnum.CHECKIN);
 176                 ResourceRestUtils.checkSuccess(restResponse);
 177                 // Create VF instances
 178                 RestResponse createVFInstResp = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF100,
 179                                 sdncDesignerDetails);
 180                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 181                 createVFInstResp = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF200, sdncDesignerDetails);
 182                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 183                 // get service
 184                 RestResponse getServiceResponse = ServiceRestUtils.getService(serviceDetails_01, sdncDesignerDetails);
 185                 ResourceRestUtils.checkSuccess(getServiceResponse);
 186                 Service service = ResponseParser.parseToObjectUsingMapper(getServiceResponse.getResponse(), Service.class);
 187                 // Verify Container requirements and Capabilities
 188                 String containerMinReq = "1";
 189                 String containerMaxReq = "2";
 190                 String containerMinCap = "1";
 191                 String containerMaxCap = "UNBOUNDED";
 192                 verifyContainerCapabilitiesAndRequirementsOccurrences(service, capabilitiesAndRequirementsType, containerMinReq,
 193                                 containerMaxReq, containerMinCap, containerMaxCap);
 194                 verifyContainerInstanceCapabilitiesAndRequirementsOccurrences(service, capabilitiesAndRequirementsType,
 195                                 resourceVF200, resourceVF100);
 196         }
 197
 198         @Test
 199         public void serviceInstanceAssociationReqMaxOccurrencesNotReached() throws Exception, Exception {
 200                 RestResponse getResourseRestResponse;
 201                 // Add instance of VFC1 (Req MIN=1 MAX=2) to VF1000
 202                 ComponentInstance componentInstanceReq = createComponentInstance(importReqDetails1, sdncDesignerDetails,
 203                                 resourceDetailsVF100);
 204                 assertNotNull(componentInstanceReq);
 205                 getResourseRestResponse = ResourceRestUtils.getResource(sdncDesignerDetails,
 206                                 resourceDetailsVF100.getUniqueId());
 207                 resourceVF100 = ResponseParser.parseToObjectUsingMapper(getResourseRestResponse.getResponse(), Resource.class);
 208                 // Add instance of VFC2 (Cap MIN=1 MAX=UNBOUNDED) to VF2000
 209                 ComponentInstance componentInstanceCap = createComponentInstance(importReqDetails2, sdncDesignerDetails,
 210                                 resourceDetailsVF200);
 211                 assertNotNull(componentInstanceCap);
 212                 getResourseRestResponse = ResourceRestUtils.getResource(sdncDesignerDetails,
 213                                 resourceDetailsVF200.getUniqueId());
 214                 resourceVF200 = ResponseParser.parseToObjectUsingMapper(getResourseRestResponse.getResponse(), Resource.class);
 215                 // Check-In both VFs
 216                 RestResponse restResponse = LifecycleRestUtils.changeResourceState(resourceDetailsVF100, sdncDesignerDetails,
 217                                 LifeCycleStatesEnum.CHECKIN);
 218                 ResourceRestUtils.checkSuccess(restResponse);
 219                 restResponse = LifecycleRestUtils.changeResourceState(resourceDetailsVF200, sdncDesignerDetails,
 220                                 LifeCycleStatesEnum.CHECKIN);
 221                 ResourceRestUtils.checkSuccess(restResponse);
 222                 // Create VF instances
 223                 RestResponse createVFInstResp = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF100,
 224                                 sdncDesignerDetails);
 225                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 226                 String fromCompInstId = ResponseParser.getUniqueIdFromResponse(createVFInstResp);
 227                 createVFInstResp = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF200, sdncDesignerDetails);
 228                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 229                 String toCompInstId = ResponseParser.getUniqueIdFromResponse(createVFInstResp);
 230                 // associate 2 VFs
 231                 String capType = capabilitiesAndRequirementsType;
 232                 String reqName = "host";
 233                 RestResponse getResourceResponse = ComponentRestUtils.getComponentRequirmentsCapabilities(sdncDesignerDetails,
 234                                 serviceDetails_01);
 235                 ResourceRestUtils.checkSuccess(getResourceResponse);
 236                 CapReqDef capReqDef = ResponseParser.parseToObject(getResourceResponse.getResponse(), CapReqDef.class);
 237                 List<CapabilityDefinition> capList = capReqDef.getCapabilities().get(capType);
 238                 List<RequirementDefinition> reqList = capReqDef.getRequirements().get(capType);
 239                 RequirementCapabilityRelDef requirementDef = getReqCapRelation(fromCompInstId, toCompInstId, capType, reqName,
 240                                 capList, reqList, componentInstanceReq.getUniqueId(), componentInstanceCap.getUniqueId());
 241                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef,
 242                                 sdncDesignerDetails, serviceDetails_01.getUniqueId(), ComponentTypeEnum.SERVICE);
 243                 ResourceRestUtils.checkSuccess(associateInstances);
 244                 // get service
 245                 RestResponse getServiceResponse = ServiceRestUtils.getService(serviceDetails_01, sdncDesignerDetails);
 246                 ResourceRestUtils.checkSuccess(getServiceResponse);
 247                 Service service = ResponseParser.parseToObjectUsingMapper(getServiceResponse.getResponse(), Service.class);
 248                 // Verify Container requirements and Capabilities
 249                 String containerMinReq = "0";
 250                 String containerMaxReq = "1";
 251                 String containerMinCap = "0";
 252                 String containerMaxCap = "UNBOUNDED";
 253                 verifyContainerCapabilitiesAndRequirementsOccurrences(service, capabilitiesAndRequirementsType, containerMinReq,
 254                                 containerMaxReq, containerMinCap, containerMaxCap);
 255                 verifyContainerInstanceCapabilitiesAndRequirementsOccurrences(service, capabilitiesAndRequirementsType,
 256                                 resourceVF200, resourceVF100);
 257         }
 258
 259         @Test
 260         public void serviceInstanceAssociationReqMaxOccurrencesIsReached() throws Exception, Exception {
 261                 RestResponse getResourseRestResponse;
 262                 // Add instance of VFC4 (Req MIN=1 MAX=1) to VF1000
 263                 ComponentInstance componentInstanceReq = createComponentInstance(importReqDetails4, sdncDesignerDetails,
 264                                 resourceDetailsVF100);
 265                 assertNotNull(componentInstanceReq);
 266                 getResourseRestResponse = ResourceRestUtils.getResource(sdncDesignerDetails,
 267                                 resourceDetailsVF100.getUniqueId());
 268                 resourceVF100 = ResponseParser.parseToObjectUsingMapper(getResourseRestResponse.getResponse(), Resource.class);
 269                 // Add instance of VFC2 (Cap MIN=1 MAX=UNBOUNDED) to VF2000
 270                 ComponentInstance componentInstanceCap = createComponentInstance(importReqDetails2, sdncDesignerDetails,
 271                                 resourceDetailsVF200);
 272                 assertNotNull(componentInstanceCap);
 273                 getResourseRestResponse = ResourceRestUtils.getResource(sdncDesignerDetails,
 274                                 resourceDetailsVF200.getUniqueId());
 275                 resourceVF200 = ResponseParser.parseToObjectUsingMapper(getResourseRestResponse.getResponse(), Resource.class);
 276                 // Check-In both VFs
 277                 RestResponse restResponse = LifecycleRestUtils.changeResourceState(resourceDetailsVF100, sdncDesignerDetails,
 278                                 LifeCycleStatesEnum.CHECKIN);
 279                 ResourceRestUtils.checkSuccess(restResponse);
 280                 restResponse = LifecycleRestUtils.changeResourceState(resourceDetailsVF200, sdncDesignerDetails,
 281                                 LifeCycleStatesEnum.CHECKIN);
 282                 ResourceRestUtils.checkSuccess(restResponse);
 283                 // Create VF instances
 284                 RestResponse createVFInstResp = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF100,
 285                                 sdncDesignerDetails);
 286                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 287                 String fromCompInstId = ResponseParser.getUniqueIdFromResponse(createVFInstResp);
 288                 createVFInstResp = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF200, sdncDesignerDetails);
 289                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 290                 String toCompInstId = ResponseParser.getUniqueIdFromResponse(createVFInstResp);
 291                 // associate 2 VFs
 292                 String capType = capabilitiesAndRequirementsType;
 293                 String reqName = "host";
 294                 RestResponse getResourceResponse = ComponentRestUtils.getComponentRequirmentsCapabilities(sdncDesignerDetails,
 295                                 serviceDetails_01);
 296                 ResourceRestUtils.checkSuccess(getResourceResponse);
 297                 CapReqDef capReqDef = ResponseParser.parseToObject(getResourceResponse.getResponse(), CapReqDef.class);
 298                 List<CapabilityDefinition> capList = capReqDef.getCapabilities().get(capType);
 299                 List<RequirementDefinition> reqList = capReqDef.getRequirements().get(capType);
 300                 RequirementCapabilityRelDef requirementDef = getReqCapRelation(fromCompInstId, toCompInstId, capType, reqName,
 301                                 capList, reqList, componentInstanceReq.getUniqueId(), componentInstanceCap.getUniqueId());
 302                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef,
 303                                 sdncDesignerDetails, serviceDetails_01.getUniqueId(), ComponentTypeEnum.SERVICE);
 304                 ResourceRestUtils.checkSuccess(associateInstances);
 305                 // get service
 306                 RestResponse getServiceResponse = ServiceRestUtils.getService(serviceDetails_01, sdncDesignerDetails);
 307                 ResourceRestUtils.checkSuccess(getServiceResponse);
 308                 Service service = ResponseParser.parseToObjectUsingMapper(getServiceResponse.getResponse(), Service.class);
 309                 // Verify Container requirements and Capabilities
 310                 String containerMinReq = "0";
 311                 String containerMaxReq = "0";
 312                 String containerMinCap = "0";
 313                 String containerMaxCap = "UNBOUNDED";
 314                 verifyContainerCapabilitiesAndRequirementsOccurrences(service, capabilitiesAndRequirementsType, containerMinReq,
 315                                 containerMaxReq, containerMinCap, containerMaxCap);
 316                 verifyContainerInstanceCapabilitiesAndRequirementsOccurrences(service, capabilitiesAndRequirementsType,
 317                                 resourceVF200, resourceVF100);
 318         }
 319
 320         @Test
 321         public void associateServiceInstanceWhenReqMaxOccurrencesAlreadyReached() throws Exception, Exception {
 322                 RestResponse getResourseRestResponse;
 323                 // Add instance of VFC4 (Req MIN=1 MAX=1) to VF1000
 324                 ComponentInstance componentInstanceReq = createComponentInstance(importReqDetails4, sdncDesignerDetails,
 325                                 resourceDetailsVF100);
 326                 assertNotNull(componentInstanceReq);
 327                 getResourseRestResponse = ResourceRestUtils.getResource(sdncDesignerDetails,
 328                                 resourceDetailsVF100.getUniqueId());
 329                 resourceVF100 = ResponseParser.parseToObjectUsingMapper(getResourseRestResponse.getResponse(), Resource.class);
 330                 // Add instance of VFC2 (Cap MIN=1 MAX=UNBOUNDED) to VF2.00
 331                 ComponentInstance componentInstanceCap = createComponentInstance(importReqDetails2, sdncDesignerDetails,
 332                                 resourceDetailsVF200);
 333                 assertNotNull(componentInstanceCap);
 334                 getResourseRestResponse = ResourceRestUtils.getResource(sdncDesignerDetails,
 335                                 resourceDetailsVF200.getUniqueId());
 336                 resourceVF200 = ResponseParser.parseToObjectUsingMapper(getResourseRestResponse.getResponse(), Resource.class);
 337                 // Check-In both VFs
 338                 RestResponse restResponse = LifecycleRestUtils.changeResourceState(resourceDetailsVF100, sdncDesignerDetails,
 339                                 LifeCycleStatesEnum.CHECKIN);
 340                 ResourceRestUtils.checkSuccess(restResponse);
 341                 restResponse = LifecycleRestUtils.changeResourceState(resourceDetailsVF200, sdncDesignerDetails,
 342                                 LifeCycleStatesEnum.CHECKIN);
 343                 ResourceRestUtils.checkSuccess(restResponse);
 344                 // Create VF instances
 345                 RestResponse createVFInstResp = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF100,
 346                                 sdncDesignerDetails);
 347                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 348                 String vf1Name = ResponseParser.getValueFromJsonResponse(createVFInstResp.getResponse(), "name");
 349                 String fromCompInstId = ResponseParser.getUniqueIdFromResponse(createVFInstResp);
 350                 createVFInstResp = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF200, sdncDesignerDetails);
 351                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 352                 String vf2Name = ResponseParser.getValueFromJsonResponse(createVFInstResp.getResponse(), "name");
 353                 String toCompInstId = ResponseParser.getUniqueIdFromResponse(createVFInstResp);
 354                 // associate 2 VFs
 355                 String capType = capabilitiesAndRequirementsType;
 356                 String reqName = "host";
 357                 RestResponse getResourceResponse = ComponentRestUtils.getComponentRequirmentsCapabilities(sdncDesignerDetails,
 358                                 serviceDetails_01);
 359                 ResourceRestUtils.checkSuccess(getResourceResponse);
 360                 CapReqDef capReqDef = ResponseParser.parseToObject(getResourceResponse.getResponse(), CapReqDef.class);
 361                 List<CapabilityDefinition> capList = capReqDef.getCapabilities().get(capType);
 362                 List<RequirementDefinition> reqList = capReqDef.getRequirements().get(capType);
 363                 RequirementCapabilityRelDef requirementDef = getReqCapRelation(fromCompInstId, toCompInstId, capType, reqName,
 364                                 capList, reqList, componentInstanceReq.getUniqueId(), componentInstanceCap.getUniqueId());
 365                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef,
 366                                 sdncDesignerDetails, serviceDetails_01.getUniqueId(), ComponentTypeEnum.SERVICE);
 367                 ResourceRestUtils.checkSuccess(associateInstances);
 368                 // associate same instances again - when requirement Max Occurrences
 369                 // reached
 370                 associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, sdncDesignerDetails,
 371                                 serviceDetails_01.getUniqueId(), ComponentTypeEnum.SERVICE);
 372                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_NOT_FOUND,
 373                                 associateInstances.getErrorCode().intValue());
 374                 ArrayList<String> varibales = new ArrayList<String>();
 375                 varibales.add(vf1Name);
 376                 varibales.add(vf2Name);
 377                 varibales.add("host");
 378                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESOURCE_INSTANCE_MATCH_NOT_FOUND.name(), varibales,
 379                                 associateInstances.getResponse());
 380                 // get service
 381                 RestResponse getServiceResponse = ServiceRestUtils.getService(serviceDetails_01, sdncDesignerDetails);
 382                 ResourceRestUtils.checkSuccess(getServiceResponse);
 383                 Service service = ResponseParser.parseToObjectUsingMapper(getServiceResponse.getResponse(), Service.class);
 384                 // Verify Container requirements and Capabilities
 385                 String containerMinReq = "0";
 386                 String containerMaxReq = "0";
 387                 String containerMinCap = "0";
 388                 String containerMaxCap = "UNBOUNDED";
 389                 verifyContainerCapabilitiesAndRequirementsOccurrences(service, capabilitiesAndRequirementsType, containerMinReq,
 390                                 containerMaxReq, containerMinCap, containerMaxCap);
 391                 verifyContainerInstanceCapabilitiesAndRequirementsOccurrences(service, capabilitiesAndRequirementsType,
 392                                 resourceVF200, resourceVF100);
 393         }
 394
 395         @Test
 396         public void serviceInstanceAssociationCapMaxOccurrencesIsReached() throws Exception, Exception {
 397                 RestResponse getResourseRestResponse;
 398                 // Add instance of VFC1 (Req MIN=1 MAX=2) to VF1000
 399                 ComponentInstance componentInstanceReq = createComponentInstance(importReqDetails1, sdncDesignerDetails,
 400                                 resourceDetailsVF100);
 401                 assertNotNull(componentInstanceReq);
 402                 getResourseRestResponse = ResourceRestUtils.getResource(sdncDesignerDetails,
 403                                 resourceDetailsVF100.getUniqueId());
 404                 resourceVF100 = ResponseParser.parseToObjectUsingMapper(getResourseRestResponse.getResponse(), Resource.class);
 405                 // Add instance of VFC3 (Cap MIN=1 MAX=1) to VF2000
 406                 ComponentInstance componentInstanceCap = createComponentInstance(importReqDetails3, sdncDesignerDetails,
 407                                 resourceDetailsVF200);
 408                 assertNotNull(componentInstanceCap);
 409                 getResourseRestResponse = ResourceRestUtils.getResource(sdncDesignerDetails,
 410                                 resourceDetailsVF200.getUniqueId());
 411                 resourceVF200 = ResponseParser.parseToObjectUsingMapper(getResourseRestResponse.getResponse(), Resource.class);
 412                 // Check-In both VFs
 413                 RestResponse restResponse = LifecycleRestUtils.changeResourceState(resourceDetailsVF100, sdncDesignerDetails,
 414                                 LifeCycleStatesEnum.CHECKIN);
 415                 ResourceRestUtils.checkSuccess(restResponse);
 416                 restResponse = LifecycleRestUtils.changeResourceState(resourceDetailsVF200, sdncDesignerDetails,
 417                                 LifeCycleStatesEnum.CHECKIN);
 418                 ResourceRestUtils.checkSuccess(restResponse);
 419                 // Create VF instances
 420                 RestResponse createVFInstResp = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF100,
 421                                 sdncDesignerDetails);
 422                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 423                 String fromCompInstId = ResponseParser.getUniqueIdFromResponse(createVFInstResp);
 424                 createVFInstResp = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF200, sdncDesignerDetails);
 425                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 426                 String toCompInstId = ResponseParser.getUniqueIdFromResponse(createVFInstResp);
 427                 // associate 2 VFs
 428                 String capType = capabilitiesAndRequirementsType;
 429                 String reqName = "host";
 430                 RestResponse getResourceResponse = ComponentRestUtils.getComponentRequirmentsCapabilities(sdncDesignerDetails,
 431                                 serviceDetails_01);
 432                 ResourceRestUtils.checkSuccess(getResourceResponse);
 433                 CapReqDef capReqDef = ResponseParser.parseToObject(getResourceResponse.getResponse(), CapReqDef.class);
 434                 List<CapabilityDefinition> capList = capReqDef.getCapabilities().get(capType);
 435                 List<RequirementDefinition> reqList = capReqDef.getRequirements().get(capType);
 436                 RequirementCapabilityRelDef requirementDef = getReqCapRelation(fromCompInstId, toCompInstId, capType, reqName,
 437                                 capList, reqList, componentInstanceReq.getUniqueId(), componentInstanceCap.getUniqueId());
 438                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef,
 439                                 sdncDesignerDetails, serviceDetails_01.getUniqueId(), ComponentTypeEnum.SERVICE);
 440                 ResourceRestUtils.checkSuccess(associateInstances);
 441                 // get service
 442                 RestResponse getServiceResponse = ServiceRestUtils.getService(serviceDetails_01, sdncDesignerDetails);
 443                 ResourceRestUtils.checkSuccess(getServiceResponse);
 444                 Service service = ResponseParser.parseToObjectUsingMapper(getServiceResponse.getResponse(), Service.class);
 445                 // Verify Container requirements and Capabilities
 446                 String containerMinReq = "0";
 447                 String containerMaxReq = "1";
 448                 String containerMinCap = "0";
 449                 String containerMaxCap = "0";
 450                 verifyContainerCapabilitiesAndRequirementsOccurrences(service, capabilitiesAndRequirementsType, containerMinReq,
 451                                 containerMaxReq, containerMinCap, containerMaxCap);
 452                 verifyContainerInstanceCapabilitiesAndRequirementsOccurrences(service, capabilitiesAndRequirementsType,
 453                                 resourceVF200, resourceVF100);
 454         }
 455
 456         @Test
 457         public void associationServiceInstanceWhenCapMaxOccurrencesAlreadyReached() throws Exception, Exception {
 458                 RestResponse getResourseRestResponse;
 459                 // Add instance of VFC1 (Req MIN=1 MAX=2) to VF1000
 460                 ComponentInstance componentInstanceReq = createComponentInstance(importReqDetails1, sdncDesignerDetails,
 461                                 resourceDetailsVF100);
 462                 assertNotNull(componentInstanceReq);
 463                 getResourseRestResponse = ResourceRestUtils.getResource(sdncDesignerDetails,
 464                                 resourceDetailsVF100.getUniqueId());
 465                 resourceVF100 = ResponseParser.parseToObjectUsingMapper(getResourseRestResponse.getResponse(), Resource.class);
 466                 // Add instance of VFC3 (Cap MIN=1 MAX=1) to VF2000
 467                 ComponentInstance componentInstanceCap = createComponentInstance(importReqDetails3, sdncDesignerDetails,
 468                                 resourceDetailsVF200);
 469                 assertNotNull(componentInstanceCap);
 470                 getResourseRestResponse = ResourceRestUtils.getResource(sdncDesignerDetails,
 471                                 resourceDetailsVF200.getUniqueId());
 472                 resourceVF200 = ResponseParser.parseToObjectUsingMapper(getResourseRestResponse.getResponse(), Resource.class);
 473                 // Check-In both VFs
 474                 RestResponse restResponse = LifecycleRestUtils.changeResourceState(resourceDetailsVF100, sdncDesignerDetails,
 475                                 LifeCycleStatesEnum.CHECKIN);
 476                 ResourceRestUtils.checkSuccess(restResponse);
 477                 restResponse = LifecycleRestUtils.changeResourceState(resourceDetailsVF200, sdncDesignerDetails,
 478                                 LifeCycleStatesEnum.CHECKIN);
 479                 ResourceRestUtils.checkSuccess(restResponse);
 480                 // Create VF instances
 481                 RestResponse createVFInstResp = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF100,
 482                                 sdncDesignerDetails);
 483                 // RestResponse createVFInstResp = createVFInstance(serviceDetails_01,
 484                 // resourceDetailsVF100, sdncDesignerDetails);
 485                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 486                 String vf1Name = ResponseParser.getValueFromJsonResponse(createVFInstResp.getResponse(), "name");
 487                 String fromCompInstId = ResponseParser.getUniqueIdFromResponse(createVFInstResp);
 488                 createVFInstResp = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF200, sdncDesignerDetails);
 489                 // createVFInstResp = createVFInstance(serviceDetails_01,
 490                 // resourceDetailsVF200, sdncDesignerDetails);
 491                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 492                 String vf2Name = ResponseParser.getValueFromJsonResponse(createVFInstResp.getResponse(), "name");
 493                 String toCompInstId = ResponseParser.getUniqueIdFromResponse(createVFInstResp);
 494                 // associate 2 VFs
 495                 String capType = capabilitiesAndRequirementsType;
 496                 String reqName = "host";
 497                 RestResponse getResourceResponse = ComponentRestUtils.getComponentRequirmentsCapabilities(sdncDesignerDetails,
 498                                 serviceDetails_01);
 499                 ResourceRestUtils.checkSuccess(getResourceResponse);
 500                 CapReqDef capReqDef = ResponseParser.parseToObject(getResourceResponse.getResponse(), CapReqDef.class);
 501                 List<CapabilityDefinition> capList = capReqDef.getCapabilities().get(capType);
 502                 List<RequirementDefinition> reqList = capReqDef.getRequirements().get(capType);
 503                 RequirementCapabilityRelDef requirementDef = getReqCapRelation(fromCompInstId, toCompInstId, capType, reqName,
 504                                 capList, reqList, componentInstanceReq.getUniqueId(), componentInstanceCap.getUniqueId());
 505                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef,
 506                                 sdncDesignerDetails, serviceDetails_01.getUniqueId(), ComponentTypeEnum.SERVICE);
 507                 ResourceRestUtils.checkSuccess(associateInstances);
 508                 // get service
 509                 RestResponse getServiceResponse = ServiceRestUtils.getService(serviceDetails_01, sdncDesignerDetails);
 510                 ResourceRestUtils.checkSuccess(getServiceResponse);
 511                 Service service = ResponseParser.parseToObjectUsingMapper(getServiceResponse.getResponse(), Service.class);
 512                 // Verify Container requirements and Capabilities
 513                 String containerMinReq = "0";
 514                 String containerMaxReq = "1";
 515                 String containerMinCap = "0";
 516                 String containerMaxCap = "0";
 517                 verifyContainerCapabilitiesAndRequirementsOccurrences(service, capabilitiesAndRequirementsType, containerMinReq,
 518                                 containerMaxReq, containerMinCap, containerMaxCap);
 519                 verifyContainerInstanceCapabilitiesAndRequirementsOccurrences(service, capabilitiesAndRequirementsType,
 520                                 resourceVF200, resourceVF100);
 521                 // associate same instances again - when requirement Max Occurrences
 522                 // reached
 523                 associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, sdncDesignerDetails,
 524                                 serviceDetails_01.getUniqueId(), ComponentTypeEnum.SERVICE);
 525                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_NOT_FOUND,
 526                                 associateInstances.getErrorCode().intValue());
 527                 ArrayList<String> varibales = new ArrayList<String>();
 528                 varibales.add(vf1Name);
 529                 varibales.add(vf2Name);
 530                 varibales.add("host");
 531                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESOURCE_INSTANCE_RELATION_NOT_FOUND.name(),
 532                                 varibales, associateInstances.getResponse());
 533         }
 534
 535         @Test
 536         public void associationAndDisassociateServiceInstancesWhenReqMaxOccurrencesAlreadyReached()
 537                         throws Exception, Exception {
 538                 RestResponse getResourseRestResponse;
 539                 // Add instance of VFC4 (Req MIN=1 MAX=1) to VF1000
 540                 ComponentInstance componentInstanceReq = createComponentInstance(importReqDetails4, sdncDesignerDetails,
 541                                 resourceDetailsVF100);
 542                 assertNotNull(componentInstanceReq);
 543                 getResourseRestResponse = ResourceRestUtils.getResource(sdncDesignerDetails,
 544                                 resourceDetailsVF100.getUniqueId());
 545                 resourceVF100 = ResponseParser.parseToObjectUsingMapper(getResourseRestResponse.getResponse(), Resource.class);
 546                 // Add instance of VFC3 (Cap MIN=1 MAX=1) to VF2000
 547                 ComponentInstance componentInstanceCap = createComponentInstance(importReqDetails3, sdncDesignerDetails,
 548                                 resourceDetailsVF200);
 549                 assertNotNull(componentInstanceCap);
 550                 getResourseRestResponse = ResourceRestUtils.getResource(sdncDesignerDetails,
 551                                 resourceDetailsVF200.getUniqueId());
 552                 resourceVF200 = ResponseParser.parseToObjectUsingMapper(getResourseRestResponse.getResponse(), Resource.class);
 553                 // Check-In both VFs
 554                 RestResponse restResponse = LifecycleRestUtils.changeResourceState(resourceDetailsVF100, sdncDesignerDetails,
 555                                 LifeCycleStatesEnum.CHECKIN);
 556                 ResourceRestUtils.checkSuccess(restResponse);
 557                 restResponse = LifecycleRestUtils.changeResourceState(resourceDetailsVF200, sdncDesignerDetails,
 558                                 LifeCycleStatesEnum.CHECKIN);
 559                 ResourceRestUtils.checkSuccess(restResponse);
 560                 // Create VF instances
 561                 RestResponse createVFInstResp = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF100,
 562                                 sdncDesignerDetails);
 563                 // RestResponse createVFInstResp = createVFInstance(serviceDetails_01,
 564                 // resourceDetailsVF100, sdncDesignerDetails);
 565                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 566                 String fromCompInstId = ResponseParser.getUniqueIdFromResponse(createVFInstResp);
 567                 createVFInstResp = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF200, sdncDesignerDetails);
 568                 // createVFInstResp = createVFInstance(serviceDetails_01,
 569                 // resourceDetailsVF200, sdncDesignerDetails);
 570                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 571                 String toCompInstId = ResponseParser.getUniqueIdFromResponse(createVFInstResp);
 572                 // associate 2 VF Instances
 573                 String capType = capabilitiesAndRequirementsType;
 574                 String reqName = "host";
 575                 RestResponse getResourceResponse = ComponentRestUtils.getComponentRequirmentsCapabilities(sdncDesignerDetails,
 576                                 serviceDetails_01);
 577                 ResourceRestUtils.checkSuccess(getResourceResponse);
 578                 CapReqDef capReqDef = ResponseParser.parseToObject(getResourceResponse.getResponse(), CapReqDef.class);
 579                 List<CapabilityDefinition> capList = capReqDef.getCapabilities().get(capType);
 580                 List<RequirementDefinition> reqList = capReqDef.getRequirements().get(capType);
 581                 RequirementCapabilityRelDef requirementDef = getReqCapRelation(fromCompInstId, toCompInstId, capType, reqName,
 582                                 capList, reqList, componentInstanceReq.getUniqueId(), componentInstanceCap.getUniqueId());
 583                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef,
 584                                 sdncDesignerDetails, serviceDetails_01.getUniqueId(), ComponentTypeEnum.SERVICE);
 585                 ResourceRestUtils.checkSuccess(associateInstances);
 586                 // get service
 587                 RestResponse getServiceResponse = ServiceRestUtils.getService(serviceDetails_01, sdncDesignerDetails);
 588                 ResourceRestUtils.checkSuccess(getServiceResponse);
 589                 Service service = ResponseParser.parseToObjectUsingMapper(getServiceResponse.getResponse(), Service.class);
 590                 // Verify Container requirements and Capabilities
 591                 String containerMinReq = "0";
 592                 String containerMaxReq = "0";
 593                 String containerMinCap = "0";
 594                 String containerMaxCap = "0";
 595                 verifyContainerCapabilitiesAndRequirementsOccurrences(service, capabilitiesAndRequirementsType, containerMinReq,
 596                                 containerMaxReq, containerMinCap, containerMaxCap);
 597                 verifyContainerInstanceCapabilitiesAndRequirementsOccurrences(service, capabilitiesAndRequirementsType,
 598                                 resourceVF200, resourceVF100);
 599                 // Disassociate 2 VF Instances
 600                 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef,
 601                                 sdncDesignerDetails, serviceDetails_01.getUniqueId(), ComponentTypeEnum.SERVICE);
 602                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS,
 603                                 dissociateInstances.getErrorCode().intValue());
 604                 assertTrue(getComponentInstancesRelations(resourceDetailsVF100.getUniqueId()).isEmpty());
 605                 // get service and verify Occurrences in container and container
 606                 // instance requirements and Capabilities
 607                 getServiceResponse = ServiceRestUtils.getService(serviceDetails_01, sdncDesignerDetails);
 608                 ResourceRestUtils.checkSuccess(getServiceResponse);
 609                 service = ResponseParser.parseToObjectUsingMapper(getServiceResponse.getResponse(), Service.class);
 610                 containerMinReq = "1";
 611                 containerMaxReq = "1";
 612                 containerMinCap = "1";
 613                 containerMaxCap = "1";
 614                 verifyContainerCapabilitiesAndRequirementsOccurrences(service, capabilitiesAndRequirementsType, containerMinReq,
 615                                 containerMaxReq, containerMinCap, containerMaxCap);
 616                 verifyContainerInstanceCapabilitiesAndRequirementsOccurrences(service, capabilitiesAndRequirementsType,
 617                                 resourceVF200, resourceVF100);
 618         }
 619
 620         @Test(enabled = false)
 621         public void aaaa() throws Exception, Exception {
 622                 RestResponse getResourseRestResponse;
 623                 // Add instance of VFC1 (Req MIN=1 MAX=2) to VF1000
 624                 ComponentInstance componentInstanceReq = createComponentInstance(importReqDetails1, sdncDesignerDetails,
 625                                 resourceDetailsVF100);
 626                 assertNotNull(componentInstanceReq);
 627                 getResourseRestResponse = ResourceRestUtils.getResource(sdncDesignerDetails,
 628                                 resourceDetailsVF100.getUniqueId());
 629                 resourceVF100 = ResponseParser.parseToObjectUsingMapper(getResourseRestResponse.getResponse(), Resource.class);
 630                 // Add instance of VFC3 (Cap MIN=1 MAX=1) to VF2000
 631                 ComponentInstance componentInstanceCap = createComponentInstance(importReqDetails3, sdncDesignerDetails,
 632                                 resourceDetailsVF200);
 633                 assertNotNull(componentInstanceCap);
 634                 getResourseRestResponse = ResourceRestUtils.getResource(sdncDesignerDetails,
 635                                 resourceDetailsVF200.getUniqueId());
 636                 resourceVF200 = ResponseParser.parseToObjectUsingMapper(getResourseRestResponse.getResponse(), Resource.class);
 637                 // Check-In both VFs
 638                 RestResponse restResponse = LifecycleRestUtils.changeResourceState(resourceDetailsVF100, sdncDesignerDetails,
 639                                 LifeCycleStatesEnum.CHECKIN);
 640                 ResourceRestUtils.checkSuccess(restResponse);
 641                 restResponse = LifecycleRestUtils.changeResourceState(resourceDetailsVF200, sdncDesignerDetails,
 642                                 LifeCycleStatesEnum.CHECKIN);
 643                 ResourceRestUtils.checkSuccess(restResponse);
 644                 // Create VF instances
 645                 // RestResponse createVFInstResp =
 646                 // createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF100,
 647                 // sdncDesignerDetails);
 648                 RestResponse createVFInstResp = createVFInstance(serviceDetails_01, resourceDetailsVF100, sdncDesignerDetails);
 649                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 650                 String vf1Name = ResponseParser.getValueFromJsonResponse(createVFInstResp.getResponse(), "name");
 651                 String fromCompInstId = ResponseParser.getUniqueIdFromResponse(createVFInstResp);
 652                 // createVFInstResp = createVFInstanceDuringSetup(serviceDetails_01,
 653                 // resourceDetailsVF200, sdncDesignerDetails);
 654                 createVFInstResp = createVFInstance(serviceDetails_01, resourceDetailsVF200, sdncDesignerDetails);
 655                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 656                 String vf2Name = ResponseParser.getValueFromJsonResponse(createVFInstResp.getResponse(), "name");
 657                 String toCompInstId = ResponseParser.getUniqueIdFromResponse(createVFInstResp);
 658                 // associate 2 VFs
 659                 String capType = capabilitiesAndRequirementsType;
 660                 String reqName = "host";
 661                 RestResponse getResourceResponse = ComponentRestUtils.getComponentRequirmentsCapabilities(sdncDesignerDetails,
 662                                 serviceDetails_01);
 663                 ResourceRestUtils.checkSuccess(getResourceResponse);
 664                 CapReqDef capReqDef = ResponseParser.parseToObject(getResourceResponse.getResponse(), CapReqDef.class);
 665                 List<CapabilityDefinition> capList = capReqDef.getCapabilities().get(capType);
 666                 List<RequirementDefinition> reqList = capReqDef.getRequirements().get(capType);
 667                 RequirementCapabilityRelDef requirementDef = getReqCapRelation(fromCompInstId, toCompInstId, capType, reqName,
 668                                 capList, reqList, componentInstanceReq.getUniqueId(), componentInstanceCap.getUniqueId());
 669                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef,
 670                                 sdncDesignerDetails, serviceDetails_01.getUniqueId(), ComponentTypeEnum.SERVICE);
 671                 ResourceRestUtils.checkSuccess(associateInstances);
 672                 getComponentAndValidateRIs(serviceDetails_01, 2, 1);
 673                 // get service
 674                 RestResponse getServiceResponse = ServiceRestUtils.getService(serviceDetails_01, sdncDesignerDetails);
 675                 ResourceRestUtils.checkSuccess(getServiceResponse);
 676                 Service service = ResponseParser.parseToObjectUsingMapper(getServiceResponse.getResponse(), Service.class);
 677                 // Verify Container requirements and Capabilities
 678                 String containerMinReq = "0";
 679                 String containerMaxReq = "1";
 680                 String containerMinCap = "0";
 681                 String containerMaxCap = "0";
 682                 verifyContainerCapabilitiesAndRequirementsOccurrences(service, capabilitiesAndRequirementsType, containerMinReq,
 683                                 containerMaxReq, containerMinCap, containerMaxCap);
 684                 verifyContainerInstanceCapabilitiesAndRequirementsOccurrences(service, capabilitiesAndRequirementsType,
 685                                 resourceVF200, resourceVF100);
 686                 // associate same instances again - when requirement Max Occurrences
 687                 // reached
 688                 associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, sdncDesignerDetails,
 689                                 serviceDetails_01.getUniqueId(), ComponentTypeEnum.SERVICE);
 690                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_NOT_FOUND,
 691                                 associateInstances.getErrorCode().intValue());
 692                 ArrayList<String> varibales = new ArrayList<String>();
 693                 varibales.add(vf1Name);
 694                 varibales.add(vf2Name);
 695                 varibales.add("host");
 696                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESOURCE_INSTANCE_RELATION_NOT_FOUND.name(),
 697                                 varibales, associateInstances.getResponse());
 698         }
 699
 700         //////////////////////////////////////////////////////////////////////////////////////////////////
 701         // US628514 Capability/Requirement "Occurrences" attribute in CREATE/DELETE
 702         ////////////////////////////////////////////////////////////////////////////////////////////////// Relation
 703         ////////////////////////////////////////////////////////////////////////////////////////////////// APIs
 704         // Container = VF , Container instance = VFC
 705         @Test
 706         public void capAndReqOccurrencesInVfAndHisInstancesNoAssociation() throws Exception, Exception {
 707                 // Add VFC1 and VFC2 instances in VF
 708                 ComponentInstance createComponentInstance1 = createComponentInstance(importReqDetails1, sdncDesignerDetails,
 709                                 resourceDetailsVF100);
 710                 assertNotNull(createComponentInstance1);
 711                 ComponentInstance createComponentInstance2 = createComponentInstance(importReqDetails2, sdncDesignerDetails,
 712                                 resourceDetailsVF100);
 713                 assertNotNull(createComponentInstance2);
 714                 // GET resource
 715                 RestResponse getResourseRestResponse = ResourceRestUtils.getResource(sdncDesignerDetails,
 716                                 resourceDetailsVF100.getUniqueId());
 717                 resourceVF100 = ResponseParser.parseToObjectUsingMapper(getResourseRestResponse.getResponse(), Resource.class);
 718                 // Verify Container requirements and Capabilities
 719                 String containerMinReq = "1";
 720                 String containerMaxReq = "2";
 721                 String containerMinCap = "1";
 722                 String containerMaxCap = "UNBOUNDED";
 723                 verifyContainerCapabilitiesAndRequirementsOccurrences(resourceVF100, capabilitiesAndRequirementsType,
 724                                 containerMinReq, containerMaxReq, containerMinCap, containerMaxCap);
 725                 verifyContainerInstanceCapabilitiesAndRequirementsOccurrences(resourceVF100, capabilitiesAndRequirementsType,
 726                                 resourceVFC2, resourceVFC1);
 727         }
 728
 729         @Test
 730         public void vfInstanceAssociationReqMaxOccurrencesNotReached() throws Exception, Exception {
 731                 // Add VFC1 (with Requirements: tosca.capabilities.Container, MIN=1
 732                 // MAX=2) instance to VF
 733                 ComponentInstance componentInstanceWithReq = createComponentInstance(importReqDetails1, sdncDesignerDetails,
 734                                 resourceDetailsVF100);
 735                 assertNotNull(componentInstanceWithReq);
 736                 // Add VFC2 (with Capabilities: tosca.capabilities.Container, MIN=1,
 737                 // MAX=UNBOUNDED ) instance to VF
 738                 ComponentInstance componentInstanceWithCap = createComponentInstance(importReqDetails2, sdncDesignerDetails,
 739                                 resourceDetailsVF100);
 740                 assertNotNull(componentInstanceWithCap);
 741                 // associate Instances
 742                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap(resourceDetailsVF100);
 743                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(componentInstanceWithReq,
 744                                 componentInstanceWithCap, capReqDefBeforeAssociate);
 745                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef,
 746                                 sdncDesignerDetails, resourceDetailsVF100.getUniqueId(), ComponentTypeEnum.RESOURCE);
 747                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
 748                 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
 749                                 resourceDetailsVF100.getUniqueId()));
 750                 // GET resource
 751                 RestResponse getResourseRestResponse = ResourceRestUtils.getResource(sdncDesignerDetails,
 752                                 resourceDetailsVF100.getUniqueId());
 753                 resourceVF100 = ResponseParser.parseToObjectUsingMapper(getResourseRestResponse.getResponse(), Resource.class);
 754                 // Verify Container requirements and Capabilities
 755                 String containerMinReq = "0";
 756                 String containerMaxReq = "1";
 757                 String containerMinCap = "0";
 758                 String containerMaxCap = "UNBOUNDED";
 759                 verifyContainerCapabilitiesAndRequirementsOccurrences(resourceVF100, capabilitiesAndRequirementsType,
 760                                 containerMinReq, containerMaxReq, containerMinCap, containerMaxCap);
 761                 verifyContainerInstanceCapabilitiesAndRequirementsOccurrences(resourceVF100, capabilitiesAndRequirementsType,
 762                                 resourceVFC2, resourceVFC1);
 763
 764         }
 765
 766         @Test
 767         public void vfInstanceAssociationReqMaxOccurrencesIsReached() throws Exception, Exception {
 768                 // Add VFC4 (with Requirements: tosca.capabilities.Container, MIN=1
 769                 // MAX=1) instance to VF
 770                 ComponentInstance componentInstanceWithReq = createComponentInstance(importReqDetails4, sdncDesignerDetails,
 771                                 resourceDetailsVF100);
 772                 assertNotNull(componentInstanceWithReq);
 773                 // Add VFC2 (with Capabilities: tosca.capabilities.Container, MIN=1,
 774                 // MAX=UNBOUNDED ) instance to VF
 775                 ComponentInstance componentInstanceWithCap = createComponentInstance(importReqDetails2, sdncDesignerDetails,
 776                                 resourceDetailsVF100);
 777                 assertNotNull(componentInstanceWithCap);
 778                 // associate Instances
 779                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap(resourceDetailsVF100);
 780                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(componentInstanceWithReq,
 781                                 componentInstanceWithCap, capReqDefBeforeAssociate);
 782                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef,
 783                                 sdncDesignerDetails, resourceDetailsVF100.getUniqueId(), ComponentTypeEnum.RESOURCE);
 784                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
 785                 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
 786                                 resourceDetailsVF100.getUniqueId()));
 787                 // GET resource
 788                 RestResponse getResourseRestResponse = ResourceRestUtils.getResource(sdncDesignerDetails,
 789                                 resourceDetailsVF100.getUniqueId());
 790                 resourceVF100 = ResponseParser.parseToObjectUsingMapper(getResourseRestResponse.getResponse(), Resource.class);
 791                 // Verify Container requirements and Capabilities
 792                 String containerMinReq = "0";
 793                 String containerMaxReq = "0";
 794                 String containerMinCap = "0";
 795                 String containerMaxCap = "UNBOUNDED";
 796                 verifyContainerCapabilitiesAndRequirementsOccurrences(resourceVF100, capabilitiesAndRequirementsType,
 797                                 containerMinReq, containerMaxReq, containerMinCap, containerMaxCap);
 798                 verifyContainerInstanceCapabilitiesAndRequirementsOccurrences(resourceVF100, capabilitiesAndRequirementsType,
 799                                 resourceVFC2, resourceVFC4);
 800         }
 801
 802         @Test
 803         public void associateVfInstanceWhenReqMaxOccurrencesAlreadyReached() throws Exception, Exception {
 804                 // Add VFC4 (with Requirements: tosca.capabilities.Container, MIN=1
 805                 // MAX=1) instance to VF
 806                 ComponentInstance componentInstanceWithReq = createComponentInstance(importReqDetails4, sdncDesignerDetails,
 807                                 resourceDetailsVF100);
 808                 assertNotNull(componentInstanceWithReq);
 809                 // Add VFC2 (with Capabilities: tosca.capabilities.Container, MIN=1,
 810                 // MAX=UNBOUNDED ) instance to VF
 811                 ComponentInstance componentInstanceWithCap = createComponentInstance(importReqDetails2, sdncDesignerDetails,
 812                                 resourceDetailsVF100);
 813                 assertNotNull(componentInstanceWithCap);
 814                 // associate Instances
 815                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap(resourceDetailsVF100);
 816                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(componentInstanceWithReq,
 817                                 componentInstanceWithCap, capReqDefBeforeAssociate);
 818                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef,
 819                                 sdncDesignerDetails, resourceDetailsVF100.getUniqueId(), ComponentTypeEnum.RESOURCE);
 820                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
 821                 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
 822                                 resourceDetailsVF100.getUniqueId()));
 823                 // GET resource
 824                 RestResponse getResourseRestResponse = ResourceRestUtils.getResource(sdncDesignerDetails,
 825                                 resourceDetailsVF100.getUniqueId());
 826                 resourceVF100 = ResponseParser.parseToObjectUsingMapper(getResourseRestResponse.getResponse(), Resource.class);
 827                 // Verify Container requirements and Capabilities
 828                 String containerMinReq = "0";
 829                 String containerMaxReq = "0";
 830                 String containerMinCap = "0";
 831                 String containerMaxCap = "UNBOUNDED";
 832                 verifyContainerCapabilitiesAndRequirementsOccurrences(resourceVF100, capabilitiesAndRequirementsType,
 833                                 containerMinReq, containerMaxReq, containerMinCap, containerMaxCap);
 834                 verifyContainerInstanceCapabilitiesAndRequirementsOccurrences(resourceVF100, capabilitiesAndRequirementsType,
 835                                 resourceVFC2, resourceVFC4);
 836                 // associate same instances again - when requirement Max Occurrences
 837                 // reached
 838                 associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, sdncDesignerDetails,
 839                                 resourceDetailsVF100.getUniqueId(), ComponentTypeEnum.RESOURCE);
 840                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_NOT_FOUND,
 841                                 associateInstances.getErrorCode().intValue());
 842                 ArrayList<String> varibales = new ArrayList<String>();
 843                 varibales.add(componentInstanceWithReq.getName());
 844                 varibales.add(componentInstanceWithCap.getName());
 845                 varibales.add("host");
 846                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESOURCE_INSTANCE_MATCH_NOT_FOUND.name(), varibales,
 847                                 associateInstances.getResponse());
 848
 849         }
 850
 851         @Test
 852         public void vfInstanceAssociationCapMaxOccurrencesIsReached() throws Exception, Exception {
 853                 // Add VFC1 (with Requirements: tosca.capabilities.Container, MIN=1
 854                 // MAX=2) instance to VF
 855                 ComponentInstance componentInstanceWithReq = createComponentInstance(importReqDetails1, sdncDesignerDetails,
 856                                 resourceDetailsVF100);
 857                 assertNotNull(componentInstanceWithReq);
 858                 // Add VFC3 (with Capabilities: tosca.capabilities.Container, MIN=1
 859                 // MAX=1 ) instance to VF
 860                 ComponentInstance componentInstanceWithCap = createComponentInstance(importReqDetails3, sdncDesignerDetails,
 861                                 resourceDetailsVF100);
 862                 assertNotNull(componentInstanceWithCap);
 863                 // associate Instances
 864                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap(resourceDetailsVF100);
 865                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(componentInstanceWithReq,
 866                                 componentInstanceWithCap, capReqDefBeforeAssociate);
 867                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef,
 868                                 sdncDesignerDetails, resourceDetailsVF100.getUniqueId(), ComponentTypeEnum.RESOURCE);
 869                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
 870                 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
 871                                 resourceDetailsVF100.getUniqueId()));
 872                 // GET resource
 873                 RestResponse getResourseRestResponse = ResourceRestUtils.getResource(sdncDesignerDetails,
 874                                 resourceDetailsVF100.getUniqueId());
 875                 resourceVF100 = ResponseParser.parseToObjectUsingMapper(getResourseRestResponse.getResponse(), Resource.class);
 876                 // Verify Container requirements and Capabilities
 877                 String containerMinReq = "0";
 878                 String containerMaxReq = "1";
 879                 String containerMinCap = "0";
 880                 String containerMaxCap = "0";
 881                 verifyContainerCapabilitiesAndRequirementsOccurrences(resourceVF100, capabilitiesAndRequirementsType,
 882                                 containerMinReq, containerMaxReq, containerMinCap, containerMaxCap);
 883                 verifyContainerInstanceCapabilitiesAndRequirementsOccurrences(resourceVF100, capabilitiesAndRequirementsType,
 884                                 resourceVFC3, resourceVFC1);
 885         }
 886
 887         @Test
 888         public void associationVfInstanceWhenCapMaxOccurrencesAlreadyReached() throws Exception, Exception {
 889                 // Add VFC1 (with Requirements: tosca.capabilities.Container, MIN=1
 890                 // MAX=2) instance to VF
 891                 ComponentInstance componentInstanceWithReq = createComponentInstance(importReqDetails1, sdncDesignerDetails,
 892                                 resourceDetailsVF100);
 893                 assertNotNull(componentInstanceWithReq);
 894                 // Add VFC3 (with Capabilities: tosca.capabilities.Container, MIN=1
 895                 // MAX=1 ) instance to VF
 896                 ComponentInstance componentInstanceWithCap = createComponentInstance(importReqDetails3, sdncDesignerDetails,
 897                                 resourceDetailsVF100);
 898                 assertNotNull(componentInstanceWithCap);
 899                 // associate Instances
 900                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap(resourceDetailsVF100);
 901                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(componentInstanceWithReq,
 902                                 componentInstanceWithCap, capReqDefBeforeAssociate);
 903                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef,
 904                                 sdncDesignerDetails, resourceDetailsVF100.getUniqueId(), ComponentTypeEnum.RESOURCE);
 905                 assertEquals("Check response code ", STATUS_CODE_SUCCESS, associateInstances.getErrorCode().intValue());
 906                 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
 907                                 resourceDetailsVF100.getUniqueId()));
 908                 // GET resource
 909                 RestResponse getResourseRestResponse = ResourceRestUtils.getResource(sdncDesignerDetails,
 910                                 resourceDetailsVF100.getUniqueId());
 911                 resourceVF100 = ResponseParser.parseToObjectUsingMapper(getResourseRestResponse.getResponse(), Resource.class);
 912                 // Verify Container requirements and Capabilities
 913                 String containerMinReq = "0";
 914                 String containerMaxReq = "1";
 915                 String containerMinCap = "0";
 916                 String containerMaxCap = "0";
 917                 verifyContainerCapabilitiesAndRequirementsOccurrences(resourceVF100, capabilitiesAndRequirementsType,
 918                                 containerMinReq, containerMaxReq, containerMinCap, containerMaxCap);
 919                 verifyContainerInstanceCapabilitiesAndRequirementsOccurrences(resourceVF100, capabilitiesAndRequirementsType,
 920                                 resourceVFC3, resourceVFC1);
 921                 // associate same instances again - when requirement Max Occurrences
 922                 // reached
 923                 associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef, sdncDesignerDetails,
 924                                 resourceDetailsVF100.getUniqueId(), ComponentTypeEnum.RESOURCE);
 925                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_NOT_FOUND,
 926                                 associateInstances.getErrorCode().intValue());
 927                 ArrayList<String> varibales = new ArrayList<String>();
 928                 varibales.add(componentInstanceWithReq.getName());
 929                 varibales.add(componentInstanceWithCap.getName());
 930                 varibales.add("host");
 931                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESOURCE_INSTANCE_RELATION_NOT_FOUND.name(),
 932                                 varibales, associateInstances.getResponse());
 933         }
 934
 935         @Test
 936         public void associationAndDisassociateVfInstancesWhenReqMaxOccurrencesAlreadyReached() throws Exception, Exception {
 937                 // Add VFC4 (with Requirements: tosca.capabilities.Container, MIN=1
 938                 // MAX=1) instance to VF
 939                 ComponentInstance componentInstanceWithReq = createComponentInstance(importReqDetails4, sdncDesignerDetails,
 940                                 resourceDetailsVF100);
 941                 assertNotNull(componentInstanceWithReq);
 942                 // Add VFC3 (with Capabilities: tosca.capabilities.Container, MIN=1
 943                 // MAX=1 ) instance to VF
 944                 ComponentInstance componentInstanceWithCap = createComponentInstance(importReqDetails3, sdncDesignerDetails,
 945                                 resourceDetailsVF100);
 946                 assertNotNull(componentInstanceWithCap);
 947                 // associate Instances
 948                 CapReqDef capReqDefBeforeAssociate = getResourceReqCap(resourceDetailsVF100);
 949                 RequirementCapabilityRelDef requirementDef = setRelationshipBetweenInstances(componentInstanceWithReq,
 950                                 componentInstanceWithCap, capReqDefBeforeAssociate);
 951                 RestResponse associateInstances = ComponentInstanceRestUtils.associateInstances(requirementDef,
 952                                 sdncDesignerDetails, resourceDetailsVF100.getUniqueId(), ComponentTypeEnum.RESOURCE);
 953                 ResourceRestUtils.checkSuccess(associateInstances);
 954                 assertTrue(checkRealtionship(requirementDef.getFromNode(), requirementDef.getToNode(),
 955                                 resourceDetailsVF100.getUniqueId()));
 956                 // GET resource
 957                 RestResponse getResourseRestResponse = ResourceRestUtils.getResource(sdncDesignerDetails,
 958                                 resourceDetailsVF100.getUniqueId());
 959                 resourceVF100 = ResponseParser.parseToObjectUsingMapper(getResourseRestResponse.getResponse(), Resource.class);
 960                 // Verify Container requirements and Capabilities
 961                 String containerMinReq = "0";
 962                 String containerMaxReq = "0";
 963                 String containerMinCap = "0";
 964                 String containerMaxCap = "0";
 965                 verifyContainerCapabilitiesAndRequirementsOccurrences(resourceVF100, capabilitiesAndRequirementsType,
 966                                 containerMinReq, containerMaxReq, containerMinCap, containerMaxCap);
 967                 verifyContainerInstanceCapabilitiesAndRequirementsOccurrences(resourceVF100, capabilitiesAndRequirementsType,
 968                                 resourceVFC3, resourceVFC4);
 969                 // Disassociate 2 Instances
 970                 RestResponse dissociateInstances = ComponentInstanceRestUtils.dissociateInstances(requirementDef,
 971                                 sdncDesignerDetails, resourceDetailsVF100.getUniqueId(), ComponentTypeEnum.RESOURCE);
 972                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS,
 973                                 dissociateInstances.getErrorCode().intValue());
 974                 assertTrue(getComponentInstancesRelations(resourceDetailsVF100.getUniqueId()).isEmpty());
 975                 // GET resource
 976                 getResourseRestResponse = ResourceRestUtils.getResource(sdncDesignerDetails,
 977                                 resourceDetailsVF100.getUniqueId());
 978                 resourceVF100 = ResponseParser.parseToObjectUsingMapper(getResourseRestResponse.getResponse(), Resource.class);
 979                 // Verify Container requirements and Capabilities
 980                 containerMinReq = "1";
 981                 containerMaxReq = "1";
 982                 containerMinCap = "1";
 983                 containerMaxCap = "1";
 984                 verifyContainerCapabilitiesAndRequirementsOccurrences(resourceVF100, capabilitiesAndRequirementsType,
 985                                 containerMinReq, containerMaxReq, containerMinCap, containerMaxCap);
 986                 verifyContainerInstanceCapabilitiesAndRequirementsOccurrences(resourceVF100, capabilitiesAndRequirementsType,
 987                                 resourceVFC3, resourceVFC4);
 988         }
 989
 990         ///////////////////////////////////////
 991
 992         private boolean checkRealtionship(String fromNode, String toNode, String resourceUniqueId) throws Exception {
 993                 List<RequirementCapabilityRelDef> componentInstancesRelations = getComponentInstancesRelations(
 994                                 resourceUniqueId);
 995                 RequirementCapabilityRelDef requirementCapabilityRelDef = componentInstancesRelations.get(0);
 996                 boolean fromNodeCheck = requirementCapabilityRelDef.getFromNode().equals(fromNode);
 997                 boolean toNodeCheck = requirementCapabilityRelDef.getToNode().equals(toNode);
 998
 999                 return fromNodeCheck && toNodeCheck;
1000         }
1001
1002         private List<RequirementCapabilityRelDef> getComponentInstancesRelations(String resourceUniqueId)
1003                         throws ClientProtocolException, IOException {
1004                 Resource resource = getVfAsResourceObject(resourceUniqueId);
1005                 List<RequirementCapabilityRelDef> componenRelationInstances = resource.getComponentInstancesRelations();
1006
1007                 return componenRelationInstances;
1008         }
1009
1010         private Resource getVfAsResourceObject(String resourceUniqueId) throws ClientProtocolException, IOException {
1011                 RestResponse getResource = ResourceRestUtils.getResource(resourceUniqueId);
1012                 Resource resource = ResponseParser.parseToObjectUsingMapper(getResource.getResponse(), Resource.class);
1013                 return resource;
1014         }
1015
1016         private RequirementCapabilityRelDef setRelationshipBetweenInstances(ComponentInstance riReq,
1017                         ComponentInstance riCap, CapReqDef capReqDef) throws Exception {
1018
1019                 String capbilityUid = capReqDef.getCapabilities().get("tosca.capabilities.Container").get(0).getUniqueId();
1020                 String requirementUid = capReqDef.getRequirements().get("tosca.capabilities.Container").get(0).getUniqueId();
1021
1022                 RequirementCapabilityRelDef requirementDef = new RequirementCapabilityRelDef();
1023                 requirementDef.setFromNode(riReq.getUniqueId());
1024                 requirementDef.setToNode(riCap.getUniqueId());
1025
1026                 RelationshipInfo pair = new RelationshipInfo();
1027                 pair.setRequirementOwnerId(riReq.getUniqueId());
1028                 pair.setCapabilityOwnerId(riCap.getUniqueId());
1029                 pair.setRequirement("host");
1030                 RelationshipImpl relationship = new RelationshipImpl();
1031                 relationship.setType("tosca.capabilities.Container");
1032                 pair.setRelationships(relationship);
1033                 pair.setCapabilityUid(capbilityUid);
1034                 pair.setRequirementUid(requirementUid);
1035                 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1036                 CapabilityRequirementRelationship capReqRel = new CapabilityRequirementRelationship();
1037                 relationships.add(capReqRel);
1038                 capReqRel.setRelation(pair);
1039                 requirementDef.setRelationships(relationships);
1040                 return requirementDef;
1041         }
1042
1043         private CapReqDef getResourceReqCap(ResourceReqDetails res) throws IOException {
1044                 RestResponse getResourceBeforeAssociate = ComponentRestUtils
1045                                 .getComponentRequirmentsCapabilities(sdncDesignerDetails, resourceDetailsVF100);
1046                 CapReqDef capReqDef = ResponseParser.parseToObject(getResourceBeforeAssociate.getResponse(), CapReqDef.class);
1047                 return capReqDef;
1048         }
1049
1050         private RestResponse importedResource(ImportReqDetails importReqDetails, String ymlFile) throws Exception {
1051                 importReqDetails = ImportUtils.getImportResourceDetailsByPathAndName(importReqDetails, testResourcesPath,
1052                                 ymlFile);
1053                 RestResponse importResourceResponse = ResourceRestUtils.createImportResource(importReqDetails,
1054                                 sdncDesignerDetails, null);
1055                 assertEquals("Check response code after importing resource", BaseRestUtils.STATUS_CODE_CREATED,
1056                                 importResourceResponse.getErrorCode().intValue());
1057                 return importResourceResponse;
1058         }
1059
1060         private ComponentInstance createComponentInstance(ResourceReqDetails res, User user, ResourceReqDetails vf)
1061                         throws Exception {
1062                 RestResponse response = ResourceRestUtils.createResourceInstance(res, user, vf.getUniqueId());
1063                 ResourceRestUtils.checkCreateResponse(response);
1064                 ComponentInstance compInstance = ResponseParser.parseToObject(response.getResponse(), ComponentInstance.class);
1065                 return compInstance;
1066         }
1067
1068         private void verifyContainerCapabilitiesAndRequirementsOccurrences(Component component,
1069                         String CapabilitiesAndRequirementsType, String minReqOccurrences, String maxReqOccurrences,
1070                         String minCapabilities, String maxCapabilities) throws Exception {
1071                 boolean isRequirementAppear = false;
1072                 boolean isCapabilityAppear = false;
1073                 List<RequirementDefinition> requirements;
1074                 List<CapabilityDefinition> capabilities;
1075                 requirements = component.getRequirements().get(CapabilitiesAndRequirementsType);
1076                 if (maxReqOccurrences == "0") {
1077                         assertTrue(requirements == null);
1078                 } // if container MAX requirement = 0
1079                 if (maxReqOccurrences != "0") {
1080                         assertNotNull(requirements);
1081                         for (RequirementDefinition req : requirements) {
1082                                 switch (req.getName()) {
1083                                 case "host":
1084                                         assertTrue("Check Min Requirement Occurrences ", req.getMinOccurrences().equals(minReqOccurrences));
1085                                         assertTrue("Check Max Requirement Occurrences ", req.getMaxOccurrences().equals(maxReqOccurrences));
1086                                         isRequirementAppear = true;
1087                                         break;
1088                                 }
1089                                 assertTrue(isRequirementAppear);
1090                                 isRequirementAppear = false;
1091                         }
1092                 }
1093                 // Container Capabilities
1094                 capabilities = component.getCapabilities().get(CapabilitiesAndRequirementsType);
1095                 if (maxCapabilities == "0") {// if container MAX capabilities = 0
1096                         assertTrue(capabilities == null);
1097                 }
1098                 if (maxCapabilities != "0") {
1099                         assertNotNull(capabilities);
1100                         for (CapabilityDefinition cap : capabilities) {
1101                                 switch (cap.getName()) {
1102                                 case "host":
1103                                         assertTrue("Check Min capability Occurrences ", cap.getMinOccurrences().equals(minCapabilities));
1104                                         assertTrue("Check Max capability Occurrences ", cap.getMaxOccurrences().equals(maxCapabilities));
1105                                         isCapabilityAppear = true;
1106                                         break;
1107                                 }
1108                                 assertTrue(isCapabilityAppear);
1109                                 isCapabilityAppear = false;
1110                         }
1111                 }
1112
1113         }
1114
1115         private void verifyContainerInstanceCapabilitiesAndRequirementsOccurrences(Component component,
1116                         String CapabilitiesAndRequirementsType, Resource vfWithCapabilities, Resource vfWithRequirements)
1117                         throws Exception {
1118                 boolean isCapReqAppear = false;
1119                 List<ComponentInstance> listOfComponentInstances = component.getComponentInstances();
1120
1121                 for (ComponentInstance instance : listOfComponentInstances) {
1122                         if (instance.getComponentUid().equals(vfWithCapabilities.getUniqueId())) {
1123                                 List<CapabilityDefinition> capFromResource = vfWithCapabilities.getCapabilities()
1124                                                 .get(CapabilitiesAndRequirementsType);
1125                                 List<CapabilityDefinition> capFromInstance = instance.getCapabilities()
1126                                                 .get(CapabilitiesAndRequirementsType);
1127                                 for (CapabilityDefinition resourceCap : capFromResource)
1128                                         for (CapabilityDefinition instanceReq : capFromInstance) {
1129                                                 if (resourceCap.getUniqueId().equals(instanceReq.getUniqueId())) {
1130                                                         assertTrue("Check Min capability Occurrences ",
1131                                                                         resourceCap.getMinOccurrences().equals(instanceReq.getMinOccurrences()));
1132                                                         assertTrue("Check Max capability Occurrences ",
1133                                                                         resourceCap.getMaxOccurrences().equals(instanceReq.getMaxOccurrences()));
1134                                                         isCapReqAppear = true;
1135                                                         break;
1136                                                 }
1137
1138                                         }
1139                         }
1140
1141                         if (instance.getComponentUid().equals(vfWithRequirements.getUniqueId())) {
1142                                 List<RequirementDefinition> reqFromAtomicResource = vfWithRequirements.getRequirements()
1143                                                 .get(CapabilitiesAndRequirementsType);
1144                                 List<RequirementDefinition> reqFromInstance = instance.getRequirements()
1145                                                 .get(CapabilitiesAndRequirementsType);
1146                                 for (RequirementDefinition resourceReq : reqFromAtomicResource)
1147                                         for (RequirementDefinition instanceReq : reqFromInstance) {
1148                                                 if (resourceReq.getUniqueId().equals(instanceReq.getUniqueId())) {
1149                                                         assertTrue("Check Min Requirement Occurrences ",
1150                                                                         resourceReq.getMinOccurrences().equals(instanceReq.getMinOccurrences()));
1151                                                         assertTrue("Check Max Requirement Occurrences ",
1152                                                                         resourceReq.getMaxOccurrences().equals(instanceReq.getMaxOccurrences()));
1153                                                         isCapReqAppear = true;
1154                                                         break;
1155                                                 }
1156                                         }
1157                         }
1158                         assertTrue(isCapReqAppear);
1159                         isCapReqAppear = false;
1160                 }
1161
1162         }
1163
1164         private RequirementCapabilityRelDef getReqCapRelation(String reqCompInstId, String capCompInstId, String capType,
1165                         String reqName, List<CapabilityDefinition> capList, List<RequirementDefinition> reqList,
1166                         String vfc1UniqueId, String vfc2UniqueId) {
1167                 return ElementFactory.getReqCapRelation(reqCompInstId, capCompInstId, vfc1UniqueId, vfc2UniqueId, capType,
1168                                 reqName, capList, reqList);
1169         }
1170
1171 }