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