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