test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/service/ServiceComponentInstanceCRUDTest.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.testng.Assert.assertEquals;
  24 import static org.testng.Assert.assertTrue;
  25
  26 import java.io.FileNotFoundException;
  27 import java.io.IOException;
  28 import java.util.ArrayList;
  29 import java.util.Arrays;
  30 import java.util.List;
  31
  32 import org.codehaus.jettison.json.JSONException;
  33 import org.json.JSONArray;
  34 import org.junit.rules.TestName;
  35 import org.openecomp.sdc.be.dao.api.ActionStatus;
  36 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  37 import org.openecomp.sdc.be.model.CapReqDef;
  38 import org.openecomp.sdc.be.model.CapabilityDefinition;
  39 import org.openecomp.sdc.be.model.Component;
  40 import org.openecomp.sdc.be.model.ComponentInstance;
  41 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
  42 import org.openecomp.sdc.be.model.RequirementDefinition;
  43 import org.openecomp.sdc.be.model.User;
  44 import org.openecomp.sdc.ci.tests.api.ComponentInstanceBaseTest;
  45 import org.openecomp.sdc.ci.tests.api.Urls;
  46 import org.openecomp.sdc.ci.tests.datatypes.ArtifactReqDetails;
  47 import org.openecomp.sdc.ci.tests.datatypes.ComponentInstanceReqDetails;
  48 import org.openecomp.sdc.ci.tests.datatypes.ComponentReqDetails;
  49 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  50 import org.openecomp.sdc.ci.tests.datatypes.ServiceReqDetails;
  51 import org.openecomp.sdc.ci.tests.datatypes.enums.ArtifactTypeEnum;
  52 import org.openecomp.sdc.ci.tests.datatypes.enums.LifeCycleStatesEnum;
  53 import org.openecomp.sdc.ci.tests.datatypes.enums.ServiceCategoriesEnum;
  54 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  55 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  56 import org.openecomp.sdc.ci.tests.utils.Utils;
  57 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  58 import org.openecomp.sdc.ci.tests.utils.rest.ArtifactRestUtils;
  59 import org.openecomp.sdc.ci.tests.utils.rest.ComponentInstanceRestUtils;
  60 import org.openecomp.sdc.ci.tests.utils.rest.ComponentRestUtils;
  61 import org.openecomp.sdc.ci.tests.utils.rest.LifecycleRestUtils;
  62 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils;
  63 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  64 import org.openecomp.sdc.ci.tests.utils.rest.ServiceRestUtils;
  65 import org.openecomp.sdc.ci.tests.utils.validation.BaseValidationUtils;
  66 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  67 import org.slf4j.Logger;
  68 import org.slf4j.LoggerFactory;
  69 import org.testng.AssertJUnit;
  70 import org.testng.annotations.BeforeMethod;
  71 import org.testng.annotations.Test;
  72
  73 public class ServiceComponentInstanceCRUDTest extends ComponentInstanceBaseTest {
  74         private static Logger log = LoggerFactory.getLogger(ServiceComponentInstanceCRUDTest.class.getName());
  75         private static final String SPACE_STRING = " ";
  76         private static String REQUIREMENT_NAME = "host";
  77         private static String CAPABILITY_TYPE = "tosca.capabilities.Container";
  78
  79         private String reqOwnerId;
  80         private String capOwnerId;
  81
  82         public ServiceComponentInstanceCRUDTest() {
  83                 super(new TestName(), ServiceComponentInstanceCRUDTest.class.getSimpleName());
  84         }
  85
  86         @BeforeMethod(alwaysRun = true)
  87         public void before() throws Exception {
  88                 init();
  89                 createComponents();
  90         }
  91
  92         private void createComponents() throws Exception {
  93                 createAtomicResource(resourceDetailsVFC_01);
  94                 createAtomicResource(resourceDetailsVFC_02);
  95                 createAtomicResource(resourceDetailsCP_01);
  96                 createAtomicResource(resourceDetailsVL_01);
  97                 createAtomicResource(resourceDetailsVL_02);
  98                 createVF(resourceDetailsVF_01);
  99                 createVF(resourceDetailsVF_02);
 100                 createService(serviceDetails_01);
 101                 certifyResource(resourceDetailsVFC_01);
 102                 certifyResource(resourceDetailsVFC_02);
 103                 RestResponse createAtomicResourceInstance = createAtomicInstanceForVFDuringSetup(resourceDetailsVF_01,
 104                                 resourceDetailsVFC_01, sdncDesignerDetails);
 105                 ResourceRestUtils.checkCreateResponse(createAtomicResourceInstance);
 106                 reqOwnerId = ResponseParser.getUniqueIdFromResponse(createAtomicResourceInstance);
 107                 createAtomicResourceInstance = createAtomicInstanceForVFDuringSetup(resourceDetailsVF_02, resourceDetailsVFC_02,
 108                                 sdncDesignerDetails);
 109                 ResourceRestUtils.checkCreateResponse(createAtomicResourceInstance);
 110                 capOwnerId = ResponseParser.getUniqueIdFromResponse(createAtomicResourceInstance);// should
 111                                                                                                                                                                                         // be
 112                                                                                                                                                                                         // updated
 113                                                                                                                                                                                         // to
 114                                                                                                                                                                                         // getUniqueIdOfFirstInstance
 115                                                                                                                                                                                         // in
 116                                                                                                                                                                                         // service
 117                                                                                                                                                                                         // context
 118         }
 119
 120         private void certifyResource(ResourceReqDetails resource) throws Exception {
 121                 changeResourceLifecycleState(resource, sdncDesignerDetails.getUserId(),
 122                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 123                 changeResourceLifecycleState(resource, sdncTesterDetails.getUserId(), LifeCycleStatesEnum.STARTCERTIFICATION);
 124                 changeResourceLifecycleState(resource, sdncTesterDetails.getUserId(), LifeCycleStatesEnum.CERTIFY);
 125         }
 126
 127         private void changeResourceLifecycleState(ResourceReqDetails resourceDetails, String userUserId,
 128                         LifeCycleStatesEnum lifeCycleStates) throws Exception {
 129                 RestResponse response = LifecycleRestUtils.changeResourceState(resourceDetails, userUserId, lifeCycleStates);
 130                 LifecycleRestUtils.checkLCS_Response(response);
 131         }
 132
 133         private void changeServiceLifecycleState(ServiceReqDetails serviceDetails, User user,
 134                         LifeCycleStatesEnum lifeCycleStates) throws Exception {
 135                 RestResponse response = LifecycleRestUtils.changeServiceState(serviceDetails, user, lifeCycleStates);
 136                 LifecycleRestUtils.checkLCS_Response(response);
 137         }
 138
 139         private void createVFInstanceFailWithoutChangeState(ActionStatus actionStatus, List<String> variables,
 140                         ResourceReqDetails vfResource, User user, int errorCode) throws Exception {
 141                 RestResponse createVFInstanceSuccessfullyWithoutChangeStateResp = createVFInstance(serviceDetails_01,
 142                                 vfResource, user);
 143                 checkErrorMessage(actionStatus, variables, errorCode, createVFInstanceSuccessfullyWithoutChangeStateResp);
 144         }
 145
 146         private void createVFInstanceFail(ActionStatus actionStatus, List<String> variables, ResourceReqDetails vfResource,
 147                         User user, int errorCode) throws Exception, FileNotFoundException, JSONException {
 148                 RestResponse createVFInstResp = createCheckedinVFInstance(serviceDetails_01, vfResource, user);
 149                 checkErrorMessage(actionStatus, variables, errorCode, createVFInstResp);
 150         }
 151
 152         private void deleteVFInstanceFail(ActionStatus actionStatus, List<String> variables, ResourceReqDetails vfResource,
 153                         User user, int errorCode) throws Exception, FileNotFoundException, JSONException {
 154                 RestResponse deleteVFInstResp = deleteVFInstance(vfResource.getUniqueId(), serviceDetails_01, user);
 155                 checkErrorMessage(actionStatus, variables, errorCode, deleteVFInstResp);
 156         }
 157
 158         private void createAtomicResourceInstanceFailWithoutChangeState(ActionStatus actionStatus, List<String> variables,
 159                         ResourceReqDetails atomicResource, User user, int errorCode)
 160                         throws Exception, FileNotFoundException, JSONException {
 161                 RestResponse createAtomicInstResp = createAtomicInstanceForService(serviceDetails_01, atomicResource, user);
 162                 checkErrorMessage(actionStatus, variables, errorCode, createAtomicInstResp);
 163         }
 164
 165         private void createAtomicResourceInstanceFail(ActionStatus actionStatus, List<String> variables,
 166                         ResourceReqDetails atomicResource, User user, int errorCode)
 167                         throws Exception, FileNotFoundException, JSONException {
 168                 RestResponse createAtomicInstResp = createCheckedinAtomicInstanceForService(serviceDetails_01, atomicResource,
 169                                 user);
 170                 checkErrorMessage(actionStatus, variables, errorCode, createAtomicInstResp);
 171         }
 172
 173         private void deleteAtomicResourceInstanceFail(ActionStatus actionStatus, List<String> variables,
 174                         ResourceReqDetails atomicResource, User user, int errorCode)
 175                         throws Exception, FileNotFoundException, JSONException {
 176                 RestResponse deleteAtomicInstResp = deleteAtomicInstanceForService(atomicResource.getUniqueId(),
 177                                 serviceDetails_01, user);
 178                 checkErrorMessage(actionStatus, variables, errorCode, deleteAtomicInstResp);
 179         }
 180
 181         private void checkErrorMessage(ActionStatus actionStatus, List<String> variables, int errorCode,
 182                         RestResponse response) throws Exception {
 183
 184                 log.debug(response.getResponse());
 185                 AssertJUnit.assertEquals(errorCode, response.getErrorCode().intValue());
 186                 ErrorValidationUtils.checkBodyResponseOnError(actionStatus.name(), variables, response.getResponse());
 187         }
 188
 189         private RestResponse createCheckedinVFInstance(ServiceReqDetails containerDetails,
 190                         ResourceReqDetails compInstOriginDetails, User modifier) throws Exception {
 191                 changeResourceLifecycleState(compInstOriginDetails, compInstOriginDetails.getCreatorUserId(),
 192                                 LifeCycleStatesEnum.CHECKIN);
 193                 return createVFInstance(containerDetails, compInstOriginDetails, modifier);
 194         }
 195
 196         private RestResponse createCheckedinAtomicInstanceForService(ServiceReqDetails containerDetails,
 197                         ResourceReqDetails compInstOriginDetails, User modifier) throws Exception {
 198                 changeResourceLifecycleState(compInstOriginDetails, compInstOriginDetails.getCreatorUserId(),
 199                                 LifeCycleStatesEnum.CHECKIN);
 200                 return createAtomicInstanceForService(containerDetails, compInstOriginDetails, modifier);
 201         }
 202
 203         private void createVFInstanceAndAtomicResourceInstanceWithoutCheckin(ResourceReqDetails vf,
 204                         ResourceReqDetails atomicResource, User user) throws Exception {
 205                 RestResponse createVFInstance = createVFInstance(serviceDetails_01, vf, user);
 206                 ResourceRestUtils.checkCreateResponse(createVFInstance);
 207                 RestResponse atomicInstanceForService = createAtomicInstanceForService(serviceDetails_01, atomicResource, user);
 208                 ResourceRestUtils.checkCreateResponse(atomicInstanceForService);
 209         }
 210
 211         private void createVFInstanceAndAtomicResourceInstanceSuccessully(ResourceReqDetails vf,
 212                         ResourceReqDetails atomicResource) throws Exception, IOException {
 213                 createVFInstanceAndAtomicResourceInstanceSuccessully(vf, atomicResource, sdncDesignerDetails);
 214         }
 215
 216         private void createVFInstanceAndAtomicResourceInstanceSuccessully(ResourceReqDetails vf,
 217                         ResourceReqDetails atomicResource, User user) throws Exception, IOException {
 218                 changeResourceLifecycleState(vf, vf.getCreatorUserId(), LifeCycleStatesEnum.CHECKIN);
 219                 changeResourceLifecycleState(atomicResource, atomicResource.getCreatorUserId(), LifeCycleStatesEnum.CHECKIN);
 220                 createVFInstanceAndAtomicResourceInstanceWithoutCheckin(vf, atomicResource, user);
 221         }
 222
 223         @Test
 224         public void createVFInstanceSuccessfullyTest() throws Exception {
 225                 RestResponse createVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_01,
 226                                 sdncDesignerDetails);
 227                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 228                 createVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_02, sdncDesignerDetails);
 229                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 230                 getComponentAndValidateRIs(serviceDetails_01, 2, 0);
 231         }
 232
 233         @Test
 234         public void createVFAndAtomicInstanceTest() throws Exception {
 235                 RestResponse createVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_01,
 236                                 sdncDesignerDetails);
 237                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 238                 createVFInstResp = createCheckedinAtomicInstanceForService(serviceDetails_01, resourceDetailsCP_01,
 239                                 sdncDesignerDetails);
 240                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 241                 createVFInstResp = createCheckedinAtomicInstanceForService(serviceDetails_01, resourceDetailsVL_01,
 242                                 sdncDesignerDetails);
 243                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 244                 createVFInstResp = createCheckedinAtomicInstanceForService(serviceDetails_01, resourceDetailsVL_02,
 245                                 sdncDesignerDetails);
 246                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 247                 getComponentAndValidateRIs(serviceDetails_01, 4, 0);
 248         }
 249
 250         @Test
 251         public void deleteAtomicInstanceTest() throws Exception {
 252                 RestResponse createVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_01,
 253                                 sdncDesignerDetails);
 254                 // 1 rel
 255                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 256                 createVFInstResp = createCheckedinAtomicInstanceForService(serviceDetails_01, resourceDetailsCP_01,
 257                                 sdncDesignerDetails);
 258                 // 2 rel
 259                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 260                 createVFInstResp = createCheckedinAtomicInstanceForService(serviceDetails_01, resourceDetailsVL_01,
 261                                 sdncDesignerDetails);
 262                 // 3 rel
 263                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 264                 createVFInstResp = createCheckedinAtomicInstanceForService(serviceDetails_01, resourceDetailsVL_02,
 265                                 sdncDesignerDetails);
 266                 // 4 rel
 267                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 268                 // To delete
 269                 String compInstId = ResponseParser.getUniqueIdFromResponse(createVFInstResp);
 270                 // 3 rel
 271                 createVFInstResp = deleteAtomicInstanceForService(compInstId, serviceDetails_01, sdncDesignerDetails);
 272                 ResourceRestUtils.checkDeleteResponse(createVFInstResp);
 273                 getComponentAndValidateRIs(serviceDetails_01, 3, 0);
 274         }
 275
 276         @Test
 277         public void deleteVFInstanceTest() throws Exception {
 278                 RestResponse createVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_01,
 279                                 sdncDesignerDetails);
 280                 // 1 rel
 281                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 282                 createVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_02, sdncDesignerDetails);
 283                 String compInstId = ResponseParser.getUniqueIdFromResponse(createVFInstResp);
 284                 // 2 rel
 285                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 286                 createVFInstResp = createCheckedinAtomicInstanceForService(serviceDetails_01, resourceDetailsCP_01,
 287                                 sdncDesignerDetails);
 288                 // 3 rel
 289                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 290                 // 2 rel
 291                 createVFInstResp = deleteVFInstance(compInstId, serviceDetails_01, sdncDesignerDetails);
 292                 ResourceRestUtils.checkDeleteResponse(createVFInstResp);
 293                 getComponentAndValidateRIs(serviceDetails_01, 2, 0);
 294         }
 295
 296         @Test
 297         public void associateDissociateTwoVFs() throws Exception {
 298
 299                 RestResponse createVFInstResp = createVFInstance(serviceDetails_01, resourceDetailsVF_01, sdncDesignerDetails);
 300                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 301                 String fromCompInstId = ResponseParser.getUniqueIdFromResponse(createVFInstResp);
 302                 createVFInstResp = createVFInstance(serviceDetails_01, resourceDetailsVF_02, sdncDesignerDetails);
 303                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 304                 String toCompInstId = ResponseParser.getUniqueIdFromResponse(createVFInstResp);
 305
 306                 String capType = CAPABILITY_TYPE;
 307                 String reqName = REQUIREMENT_NAME;
 308
 309                 RestResponse getResourceResponse = ComponentRestUtils.getComponentRequirmentsCapabilities(sdncDesignerDetails,
 310                                 serviceDetails_01);
 311                 ResourceRestUtils.checkSuccess(getResourceResponse);
 312                 CapReqDef capReqDef = ResponseParser.parseToObject(getResourceResponse.getResponse(), CapReqDef.class);
 313                 List<CapabilityDefinition> capList = capReqDef.getCapabilities().get(capType);
 314                 List<RequirementDefinition> reqList = capReqDef.getRequirements().get(capType);
 315
 316                 RequirementCapabilityRelDef requirementDef = getReqCapRelation(fromCompInstId, toCompInstId, capType, reqName,
 317                                 capList, reqList);
 318
 319                 associateComponentInstancesForService(requirementDef, serviceDetails_01, sdncDesignerDetails);
 320                 getResourceResponse = ComponentRestUtils.getComponentRequirmentsCapabilities(sdncDesignerDetails,
 321                                 serviceDetails_01);
 322                 capReqDef = ResponseParser.parseToObject(getResourceResponse.getResponse(), CapReqDef.class);
 323                 List<RequirementDefinition> list = capReqDef.getRequirements().get(capType);
 324                 AssertJUnit.assertEquals("Check requirement", null, list);
 325                 getComponentAndValidateRIs(serviceDetails_01, 2, 1);
 326
 327                 dissociateComponentInstancesForService(requirementDef, serviceDetails_01, sdncDesignerDetails);
 328                 getResourceResponse = ComponentRestUtils.getComponentRequirmentsCapabilities(sdncDesignerDetails,
 329                                 serviceDetails_01);
 330                 capReqDef = ResponseParser.parseToObject(getResourceResponse.getResponse(), CapReqDef.class);
 331                 list = capReqDef.getRequirements().get(capType);
 332                 AssertJUnit.assertEquals("Check requirement", 1, list.size());
 333                 getComponentAndValidateRIs(serviceDetails_01, 2, 0);
 334         }
 335
 336         private RequirementCapabilityRelDef getReqCapRelation(String reqCompInstId, String capCompInstId, String capType,
 337                         String reqName, List<CapabilityDefinition> capList, List<RequirementDefinition> reqList) {
 338                 return ElementFactory.getReqCapRelation(reqCompInstId, capCompInstId, reqOwnerId, capOwnerId, capType, reqName,
 339                                 capList, reqList);
 340         }
 341
 342         @Test
 343         public void createResourceInstanceByDifferentDesignerTest() throws Exception {
 344                 createVFInstanceFail(ActionStatus.RESTRICTED_OPERATION, new ArrayList<String>(), resourceDetailsVF_01,
 345                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER2), 409);
 346                 createAtomicResourceInstanceFail(ActionStatus.RESTRICTED_OPERATION, new ArrayList<String>(),
 347                                 resourceDetailsCP_01, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER2), 409);
 348                 getComponentAndValidateRIs(serviceDetails_01, 0, 0);
 349         }
 350
 351         @Test
 352         public void createResourceInstanceByDifferentDesignerTest_ServiceIsCheckedin() throws Exception {
 353                 User designer2 = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER2);
 354
 355                 changeServiceLifecycleState(serviceDetails_01, sdncDesignerDetails, LifeCycleStatesEnum.CHECKIN);
 356                 changeServiceLifecycleState(serviceDetails_01, designer2, LifeCycleStatesEnum.CHECKOUT);
 357
 358                 createVFInstanceAndAtomicResourceInstanceSuccessully(resourceDetailsVF_01, resourceDetailsCP_01, designer2);
 359                 getComponentAndValidateRIs(serviceDetails_01, 2, 0);
 360
 361         }
 362
 363         @Test
 364         public void createResourceInstanceByTester() throws Exception {
 365                 createVFInstanceFail(ActionStatus.RESTRICTED_OPERATION, new ArrayList<String>(), resourceDetailsVF_01,
 366                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), 409);
 367                 createAtomicResourceInstanceFail(ActionStatus.RESTRICTED_OPERATION, new ArrayList<String>(),
 368                                 resourceDetailsCP_01, ElementFactory.getDefaultUser(UserRoleEnum.TESTER), 409);
 369                 getComponentAndValidateRIs(serviceDetails_01, 0, 0);
 370         }
 371
 372         @Test
 373         public void createResourceInstanceWithNotASDCUserTest() throws Exception {
 374                 sdncDesignerDetails.setUserId("ab0001");
 375                 createVFInstanceFail(ActionStatus.RESTRICTED_OPERATION, new ArrayList<String>(), resourceDetailsVF_01,
 376                                 sdncDesignerDetails, 409);
 377                 createAtomicResourceInstanceFail(ActionStatus.RESTRICTED_OPERATION, new ArrayList<String>(),
 378                                 resourceDetailsCP_01, sdncDesignerDetails, 409);
 379                 getComponentAndValidateRIs(serviceDetails_01, 0, 0);
 380         }
 381
 382         @Test
 383         public void createResourceInstanceWithEmptyUserIdTest() throws Exception {
 384                 sdncDesignerDetails.setUserId("");
 385                 createVFInstanceFail(ActionStatus.MISSING_INFORMATION, new ArrayList<String>(), resourceDetailsVF_01,
 386                                 sdncDesignerDetails, 403);
 387                 createAtomicResourceInstanceFail(ActionStatus.MISSING_INFORMATION, new ArrayList<String>(),
 388                                 resourceDetailsCP_01, sdncDesignerDetails, 403);
 389                 getComponentAndValidateRIs(serviceDetails_01, 0, 0);
 390         }
 391
 392         @Test
 393         public void createResourceInstanceWithEmptyServiceUidTest() throws Exception {
 394                 serviceDetails_01.setUniqueId("");
 395                 RestResponse createVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_01,
 396                                 sdncDesignerDetails);
 397                 assertEquals(404, createVFInstResp.getErrorCode().intValue());
 398                 RestResponse createAtomicInstResp = createCheckedinAtomicInstanceForService(serviceDetails_01,
 399                                 resourceDetailsCP_01, sdncDesignerDetails);
 400                 assertEquals(404, createAtomicInstResp.getErrorCode().intValue());
 401         }
 402
 403         @Test
 404         public void createResourceInstanceWhileResourceNotExistTest() throws Exception {
 405                 String vfResourceUniqueId = "1234";
 406                 String atomicResourceUniqueId = "5678";
 407
 408                 resourceDetailsVF_01.setUniqueId(vfResourceUniqueId);
 409                 resourceDetailsCP_01.setUniqueId(atomicResourceUniqueId);
 410
 411                 createVFInstanceFailWithoutChangeState(ActionStatus.RESOURCE_NOT_FOUND,
 412                                 new ArrayList<String>(Arrays.asList("")), resourceDetailsVF_01, sdncDesignerDetails, 404);
 413                 createAtomicResourceInstanceFailWithoutChangeState(ActionStatus.RESOURCE_NOT_FOUND,
 414                                 new ArrayList<String>(Arrays.asList("")), resourceDetailsCP_01, sdncDesignerDetails, 404);
 415         }
 416
 417         @Test
 418         public void createResourceInstanceInServiceNotExistsTest() throws Exception {
 419                 serviceDetails_01.setUniqueId("1234");
 420                 createVFInstanceFail(ActionStatus.SERVICE_NOT_FOUND, new ArrayList<String>(Arrays.asList("")),
 421                                 resourceDetailsVF_01, sdncDesignerDetails, 404);
 422                 createAtomicResourceInstanceFail(ActionStatus.SERVICE_NOT_FOUND, new ArrayList<String>(Arrays.asList("")),
 423                                 resourceDetailsCP_01, sdncDesignerDetails, 404);
 424         }
 425
 426         @Test
 427         public void createResourceInstanceInCheckedinServiceTest() throws Exception {
 428                 changeServiceLifecycleState(serviceDetails_01, sdncDesignerDetails, LifeCycleStatesEnum.CHECKIN);
 429
 430                 createVFInstanceFailWithoutChangeState(ActionStatus.RESTRICTED_OPERATION, new ArrayList<String>(),
 431                                 resourceDetailsVF_01, sdncDesignerDetails, 409);
 432                 createAtomicResourceInstanceFailWithoutChangeState(ActionStatus.RESTRICTED_OPERATION, new ArrayList<String>(),
 433                                 resourceDetailsCP_01, sdncDesignerDetails, 409);
 434                 getComponentAndValidateRIs(serviceDetails_01, 0, 0);
 435         }
 436
 437         @Test(enabled = false)
 438         public void createResourceInstance_ResourceInCheckoutStateTest() throws Exception {
 439                 LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails, "0.1",
 440                                 LifeCycleStatesEnum.CHECKIN);
 441                 RestResponse createVFInstanceWithoutChangeStateResp = createVFInstance(serviceDetails_01, resourceDetailsVF_01,
 442                                 sdncDesignerDetails);
 443                 ComponentInstanceRestUtils.checkCreateResponse(createVFInstanceWithoutChangeStateResp);
 444                 RestResponse createAtomicInstWithoutCheangeStateResp = createAtomicInstanceForService(serviceDetails_01,
 445                                 resourceDetailsCP_01, sdncDesignerDetails);
 446                 ComponentInstanceRestUtils.checkCreateResponse(createAtomicInstWithoutCheangeStateResp);
 447                 getComponentAndValidateRIs(serviceDetails_01, 2, 0);
 448         }
 449
 450         @Test
 451         public void createResourceInstance_ResourceInCertificationRequestStateTest() throws Exception {
 452                 changeResourceLifecycleState(resourceDetailsVF_01, sdncDesignerDetails.getUserId(),
 453                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 454                 changeResourceLifecycleState(resourceDetailsCP_01, sdncDesignerDetails.getUserId(),
 455                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 456
 457                 createVFInstanceAndAtomicResourceInstanceSuccessully(resourceDetailsVF_01, resourceDetailsCP_01);
 458                 getComponentAndValidateRIs(serviceDetails_01, 2, 0);
 459         }
 460
 461         @Test
 462         public void createResourceInstance_startCertificationStateTest() throws Exception {
 463                 changeResourceLifecycleState(resourceDetailsVF_01, sdncDesignerDetails.getUserId(),
 464                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 465                 changeResourceLifecycleState(resourceDetailsCP_01, sdncDesignerDetails.getUserId(),
 466                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 467
 468                 changeResourceLifecycleState(resourceDetailsVF_01, sdncTesterDetails.getUserId(),
 469                                 LifeCycleStatesEnum.STARTCERTIFICATION);
 470                 changeResourceLifecycleState(resourceDetailsCP_01, sdncTesterDetails.getUserId(),
 471                                 LifeCycleStatesEnum.STARTCERTIFICATION);
 472
 473                 createVFInstanceAndAtomicResourceInstanceWithoutCheckin(resourceDetailsVF_01, resourceDetailsCP_01,
 474                                 sdncDesignerDetails);
 475                 getComponentAndValidateRIs(serviceDetails_01, 2, 0);
 476
 477         }
 478
 479         @Test
 480         public void createResourceInstance_certifiedStateTest() throws Exception {
 481                 certifyResource(resourceDetailsVF_01);
 482                 certifyResource(resourceDetailsCP_01);
 483
 484                 createVFInstanceAndAtomicResourceInstanceWithoutCheckin(resourceDetailsVF_01, resourceDetailsCP_01,
 485                                 sdncDesignerDetails);
 486         }
 487
 488         @Test
 489         public void createResourceInstance_OneHasDifferentOwner() throws Exception {
 490                 User designer2 = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER2);
 491
 492                 ResourceReqDetails vfResource = new ResourceReqDetails(resourceDetailsVF_01, "0.1");
 493                 vfResource.setUniqueId(null);
 494                 vfResource.setName("newVF");
 495                 vfResource.setTags(new ArrayList<String>(Arrays.asList(vfResource.getName())));
 496                 createVF(vfResource, designer2);
 497
 498                 RestResponse atomicInstanceForService = createCheckedinAtomicInstanceForService(serviceDetails_01,
 499                                 resourceDetailsCP_01, sdncDesignerDetails);
 500                 ResourceRestUtils.checkCreateResponse(atomicInstanceForService);
 501                 createVFInstanceFailWithoutChangeState(ActionStatus.RESTRICTED_OPERATION, new ArrayList<String>(), vfResource,
 502                                 designer2, 409);
 503
 504                 getComponentAndValidateRIs(serviceDetails_01, 1, 0);
 505         }
 506
 507         @Test
 508         public void indexesOfVFInstancesTest() throws Exception {
 509                 String firstInstanceName = resourceDetailsVF_01.getName() + SPACE_STRING + "1";
 510                 String secondInstanceName = resourceDetailsVF_01.getName() + SPACE_STRING + "2";
 511                 String thirdInstanceName = resourceDetailsVF_01.getName() + SPACE_STRING + "3";
 512
 513                 LifecycleRestUtils.changeResourceState(resourceDetailsVF_01, sdncDesignerDetails, "0.1",
 514                                 LifeCycleStatesEnum.CHECKIN);
 515
 516                 RestResponse createFirstVFInstResp = createVFInstance(serviceDetails_01, resourceDetailsVF_01,
 517                                 sdncDesignerDetails);
 518                 ResourceRestUtils.checkCreateResponse(createFirstVFInstResp);
 519                 RestResponse createSecondVFInstResp = createVFInstance(serviceDetails_01, resourceDetailsVF_01,
 520                                 sdncDesignerDetails);
 521                 ResourceRestUtils.checkCreateResponse(createSecondVFInstResp);
 522                 RestResponse createThirdVFInstResp = createVFInstance(serviceDetails_01, resourceDetailsVF_01,
 523                                 sdncDesignerDetails);
 524                 ResourceRestUtils.checkCreateResponse(createThirdVFInstResp);
 525
 526                 Component service = getComponentAndValidateRIs(serviceDetails_01, 3, 0);
 527                 List<ComponentInstance> componentInstancesList = service.getComponentInstances();
 528                 for (ComponentInstance instance : componentInstancesList) {
 529                         String instanceName = instance.getName();
 530                         boolean isEqualToFirstInstanceName = instanceName.equals(firstInstanceName);
 531                         boolean isEqualToSecondInstanceName = instanceName.equals(secondInstanceName);
 532                         boolean isEqualToThirdInstanceName = instanceName.equals(thirdInstanceName);
 533                         assertTrue(isEqualToFirstInstanceName || isEqualToSecondInstanceName || isEqualToThirdInstanceName);
 534                 }
 535         }
 536
 537         @Test
 538         public void vfInstancesAmountInTwoServiceVersionsTest() throws Exception {
 539                 String oldServiceUniqueId = serviceDetails_01.getUniqueId();
 540
 541                 createTwoCheckedinVFInstances();
 542
 543                 changeServiceLifecycleState(serviceDetails_01, sdncDesignerDetails, LifeCycleStatesEnum.CHECKIN);
 544                 changeServiceLifecycleState(serviceDetails_01, sdncDesignerDetails, LifeCycleStatesEnum.CHECKOUT);
 545
 546                 String newSerivceUniqueIdAfterChangeLifecycleState = serviceDetails_01.getUniqueId();
 547                 getComponentAndValidateRIsAfterChangeLifecycleState(oldServiceUniqueId, serviceDetails_01, 2, 0);
 548
 549                 // Check old version
 550                 checkServiceOldVersionRIs(oldServiceUniqueId, newSerivceUniqueIdAfterChangeLifecycleState, 2, 0);
 551
 552                 // Add one more resource instance to second version of service
 553                 LifecycleRestUtils.changeResourceState(resourceDetailsVL_01, sdncDesignerDetails, "0.1",
 554                                 LifeCycleStatesEnum.CHECKIN);
 555                 RestResponse createAtomicResourceInstResp = createAtomicResourceInstanceToSecondServiceVersion(
 556                                 newSerivceUniqueIdAfterChangeLifecycleState, resourceDetailsVL_01);
 557                 String atomicResourceUniqueId = ResponseParser.getUniqueIdFromResponse(createAtomicResourceInstResp);
 558                 getComponentAndValidateRIsAfterAddingAtomicResourceInstance(oldServiceUniqueId, serviceDetails_01, 3, 0);
 559
 560                 // Check that RIs are same as in the beginning - like in old version of
 561                 // service
 562                 deleteCompInstReqCapFromExpected(atomicResourceUniqueId);
 563                 checkServiceOldVersionRIs(oldServiceUniqueId, newSerivceUniqueIdAfterChangeLifecycleState, 2, 0);
 564
 565         }
 566
 567         private void createTwoCheckedinVFInstances() throws Exception {
 568                 RestResponse createFirstVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_01,
 569                                 sdncDesignerDetails);
 570                 ResourceRestUtils.checkCreateResponse(createFirstVFInstResp);
 571                 RestResponse createSecondVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_02,
 572                                 sdncDesignerDetails);
 573                 ResourceRestUtils.checkCreateResponse(createSecondVFInstResp);
 574         }
 575
 576         private void getComponentAndValidateRIsAfterAddingAtomicResourceInstance(String oldComponentUniqueId,
 577                         ComponentReqDetails componentDetails, int numOfRIs, int numOfRelations) throws Exception {
 578                 getComponentAndValidateRIsAfterChangeLifecycleState(oldComponentUniqueId, componentDetails, numOfRIs,
 579                                 numOfRelations);
 580
 581         }
 582
 583         private void checkServiceOldVersionRIs(String oldUniqueId, String newUniqueId, int numOfRIs, int numOfRelations)
 584                         throws IOException, Exception {
 585                 serviceDetails_01.setUniqueId(oldUniqueId);
 586                 getComponentAndValidateRIsAfterChangeLifecycleState(newUniqueId, serviceDetails_01, numOfRIs, numOfRelations);
 587         }
 588
 589         private RestResponse createAtomicResourceInstanceToSecondServiceVersion(String secondServiceUniqueId,
 590                         ResourceReqDetails resourceToAdd) throws Exception {
 591                 serviceDetails_01.setUniqueId(secondServiceUniqueId);
 592                 RestResponse createAtomicResourceInstResp = createAtomicInstanceForService(serviceDetails_01, resourceToAdd,
 593                                 sdncDesignerDetails);
 594                 ResourceRestUtils.checkCreateResponse(createAtomicResourceInstResp);
 595                 return createAtomicResourceInstResp;
 596         }
 597
 598         @Test
 599         public void createResourceInstanceToUnsupportedComponentTest() throws Exception {
 600                 String unsupportedType = "unsupported";
 601                 ComponentInstanceReqDetails resourceInstanceReqDetails = ElementFactory
 602                                 .getComponentResourceInstance(resourceDetailsCP_01);
 603                 RestResponse createResourceInstanceResponse = ComponentInstanceRestUtils.createComponentInstance(
 604                                 resourceInstanceReqDetails, sdncDesignerDetails, serviceDetails_01.getUniqueId(), unsupportedType);
 605                 checkErrorMessage(ActionStatus.UNSUPPORTED_ERROR, new ArrayList<String>(Arrays.asList(unsupportedType)), 400,
 606                                 createResourceInstanceResponse);
 607         }
 608
 609         @Test
 610         public void deleteResourceInstanceByDifferentDesignerTest() throws Exception {
 611
 612                 createVFInstanceAndAtomicResourceInstanceSuccessully(resourceDetailsVF_01, resourceDetailsCP_01);
 613
 614                 deleteVFInstanceFail(ActionStatus.RESTRICTED_OPERATION, new ArrayList<String>(), resourceDetailsVF_01,
 615                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER2), 409);
 616                 deleteAtomicResourceInstanceFail(ActionStatus.RESTRICTED_OPERATION, new ArrayList<String>(),
 617                                 resourceDetailsCP_01, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER2), 409);
 618                 getComponentAndValidateRIs(serviceDetails_01, 2, 0);
 619         }
 620
 621         @Test
 622         public void deleteResourceInstanceByDifferentDesignerTest_ServiceIsCheckedin() throws Exception {
 623
 624                 String oldServiceUniqueId = serviceDetails_01.getUniqueId();
 625
 626                 RestResponse createVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_01,
 627                                 sdncDesignerDetails);
 628                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
 629                 RestResponse createAtomicResourceInstResp = createCheckedinAtomicInstanceForService(serviceDetails_01,
 630                                 resourceDetailsCP_01, sdncDesignerDetails);
 631                 ResourceRestUtils.checkCreateResponse(createAtomicResourceInstResp);
 632
 633                 changeServiceLifecycleState(serviceDetails_01, sdncDesignerDetails, LifeCycleStatesEnum.CHECKIN);
 634                 changeServiceLifecycleState(serviceDetails_01, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER2),
 635                                 LifeCycleStatesEnum.CHECKOUT);
 636                 String newServiceUniqueId = serviceDetails_01.getUniqueId();
 637
 638                 String oldVFInstanceUniqueId = ResponseParser.getUniqueIdFromResponse(createVFInstResp);
 639                 String newVFInstanceUniqueId = oldVFInstanceUniqueId.replaceAll(oldServiceUniqueId,
 640                                 serviceDetails_01.getUniqueId());
 641                 String oldAtomicResourceInstanceUniqueId = ResponseParser.getUniqueIdFromResponse(createAtomicResourceInstResp);
 642                 String newAtomicResourceInstanceUniqueId = oldAtomicResourceInstanceUniqueId.replaceAll(oldServiceUniqueId,
 643                                 serviceDetails_01.getUniqueId());
 644
 645                 deleteVFInstanceAndAtomicResourceInstanceSuccessfully(newVFInstanceUniqueId, newAtomicResourceInstanceUniqueId,
 646                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER2));
 647
 648                 serviceDetails_01.setUniqueId(oldServiceUniqueId);
 649                 getComponentAndValidateRIs(serviceDetails_01, 2, 0);
 650
 651                 serviceDetails_01.setUniqueId(newServiceUniqueId);
 652                 updateExpectedReqCapAfterChangeLifecycleState(oldServiceUniqueId, serviceDetails_01.getUniqueId());
 653                 deleteCompInstReqCapFromExpected(newVFInstanceUniqueId);
 654                 deleteCompInstReqCapFromExpected(newAtomicResourceInstanceUniqueId);
 655                 getComponentAndValidateRIs(serviceDetails_01, 0, 0);
 656         }
 657
 658         private void deleteVFInstanceAndAtomicResourceInstanceSuccessfully(String vfInstanceUniqueId,
 659                         String atomicResourceInstanceUniqueId) throws IOException, Exception {
 660                 deleteVFInstanceAndAtomicResourceInstanceSuccessfully(vfInstanceUniqueId, atomicResourceInstanceUniqueId,
 661                                 sdncDesignerDetails);
 662         }
 663
 664         private void deleteVFInstanceAndAtomicResourceInstanceSuccessfully(String vfInstanceUniqueId,
 665                         String atomicResourceInstanceUniqueId, User user) throws IOException, Exception {
 666                 RestResponse deleteVFInstResp = deleteVFInstance(vfInstanceUniqueId, serviceDetails_01, user);
 667                 ResourceRestUtils.checkDeleteResponse(deleteVFInstResp);
 668                 RestResponse deleteAtomicResourceInsResp = deleteAtomicInstanceForService(atomicResourceInstanceUniqueId,
 669                                 serviceDetails_01, user);
 670                 ResourceRestUtils.checkDeleteResponse(deleteAtomicResourceInsResp);
 671         }
 672
 673         @Test
 674         public void deleteResourceInstanceByTesterUserTest() throws Exception {
 675                 createVFInstanceAndAtomicResourceInstanceSuccessully(resourceDetailsVF_01, resourceDetailsCP_01);
 676                 deleteVFInstanceFail(ActionStatus.RESTRICTED_OPERATION, new ArrayList<String>(), resourceDetailsVF_01,
 677                                 ElementFactory.getDefaultUser(UserRoleEnum.TESTER), 409);
 678                 deleteAtomicResourceInstanceFail(ActionStatus.RESTRICTED_OPERATION, new ArrayList<String>(),
 679                                 resourceDetailsCP_01, ElementFactory.getDefaultUser(UserRoleEnum.TESTER), 409);
 680                 getComponentAndValidateRIs(serviceDetails_01, 2, 0);
 681         }
 682
 683         @Test
 684         public void deleteResourceInstanceByNotASDCUserTest() throws Exception {
 685                 createVFInstanceAndAtomicResourceInstanceSuccessully(resourceDetailsVF_01, resourceDetailsCP_01);
 686                 User notASDCUser = new User();
 687                 notASDCUser.setUserId("ab0001");
 688                 deleteVFInstanceFail(ActionStatus.RESTRICTED_OPERATION, new ArrayList<String>(), resourceDetailsVF_01,
 689                                 notASDCUser, 409);
 690                 deleteAtomicResourceInstanceFail(ActionStatus.RESTRICTED_OPERATION, new ArrayList<String>(),
 691                                 resourceDetailsCP_01, notASDCUser, 409);
 692                 getComponentAndValidateRIs(serviceDetails_01, 2, 0);
 693         }
 694
 695         @Test
 696         public void deleteResourceInstanceFromCheckedinServiceTest() throws Exception {
 697                 createVFInstanceAndAtomicResourceInstanceSuccessully(resourceDetailsVF_01, resourceDetailsCP_01);
 698                 changeServiceLifecycleState(serviceDetails_01, sdncDesignerDetails, LifeCycleStatesEnum.CHECKIN);
 699                 deleteVFInstanceFail(ActionStatus.RESTRICTED_OPERATION, new ArrayList<String>(), resourceDetailsVF_01,
 700                                 sdncDesignerDetails, 409);
 701                 deleteAtomicResourceInstanceFail(ActionStatus.RESTRICTED_OPERATION, new ArrayList<String>(),
 702                                 resourceDetailsCP_01, sdncDesignerDetails, 409);
 703                 getComponentAndValidateRIs(serviceDetails_01, 2, 0);
 704         }
 705
 706         @Test
 707         public void deleteResourceInstanceWhileResourceCertifiedStateTest() throws Exception {
 708                 certifyResource(resourceDetailsVF_01);
 709                 certifyResource(resourceDetailsCP_01);
 710
 711                 RestResponse createVFInstance = createVFInstance(serviceDetails_01, resourceDetailsVF_01, sdncDesignerDetails);
 712                 ResourceRestUtils.checkCreateResponse(createVFInstance);
 713                 String vfInstUniqueId = ResponseParser.getUniqueIdFromResponse(createVFInstance);
 714                 RestResponse atomicInstanceForService = createAtomicInstanceForService(serviceDetails_01, resourceDetailsCP_01,
 715                                 sdncDesignerDetails);
 716                 ResourceRestUtils.checkCreateResponse(atomicInstanceForService);
 717                 String atomicInstUniqueId = ResponseParser.getUniqueIdFromResponse(atomicInstanceForService);
 718
 719                 deleteVFInstanceAndAtomicResourceInstanceSuccessfully(vfInstUniqueId, atomicInstUniqueId);
 720
 721                 getComponentAndValidateRIs(serviceDetails_01, 0, 0);
 722         }
 723
 724         // fail - bug DE191849
 725         @Test
 726         public void deleteNotFoundResourceInstanceTest() throws Exception, Throwable {
 727
 728                 resourceDetailsVF_01.setUniqueId("1234");
 729                 resourceDetailsCP_01.setUniqueId("5678");
 730
 731                 deleteVFInstanceFail(ActionStatus.RESOURCE_NOT_FOUND, new ArrayList<String>(Arrays.asList("")),
 732                                 resourceDetailsVF_01, sdncDesignerDetails, 404);
 733                 deleteAtomicResourceInstanceFail(ActionStatus.RESOURCE_NOT_FOUND, new ArrayList<String>(Arrays.asList("")),
 734                                 resourceDetailsCP_01, sdncDesignerDetails, 404);
 735                 getComponentAndValidateRIs(serviceDetails_01, 0, 0);
 736
 737                 // {"requestError":{"serviceException":{"messageId":"SVC4503","text":"Error:
 738                 // Requested '%1' service was not found.","variables":["1234"]}}}>
 739         }
 740
 741         @Test
 742         public void deleteResourceInstanceFromServiceNotFoundTest() throws Exception, Throwable {
 743                 serviceDetails_01.setUniqueId("1234");
 744                 deleteVFInstanceFail(ActionStatus.SERVICE_NOT_FOUND, new ArrayList<String>(Arrays.asList("")),
 745                                 resourceDetailsVF_01, sdncDesignerDetails, 404);
 746                 deleteAtomicResourceInstanceFail(ActionStatus.SERVICE_NOT_FOUND, new ArrayList<String>(Arrays.asList("")),
 747                                 resourceDetailsCP_01, sdncDesignerDetails, 404);
 748         }
 749
 750         @Test
 751         public void deleteResourceInstanceFromUnsupportedTypeTest() throws Exception {
 752                 String unsupportedType = "unsupportedType";
 753                 RestResponse deleteVFInstanceResponse = ComponentInstanceRestUtils.deleteComponentInstance(sdncDesignerDetails,
 754                                 serviceDetails_01.getUniqueId(), resourceDetailsVF_01.getUniqueId(), unsupportedType);
 755                 checkErrorMessage(ActionStatus.UNSUPPORTED_ERROR, new ArrayList<String>(Arrays.asList(unsupportedType)), 400,
 756                                 deleteVFInstanceResponse);
 757                 getComponentAndValidateRIs(serviceDetails_01, 0, 0);
 758         }
 759
 760         @Test
 761         public void deleteResourceInstanceWithEmptyServiceUidTest() throws Exception, Throwable {
 762                 serviceDetails_01.setUniqueId("");
 763                 RestResponse deleteVFInstResp = deleteVFInstance(resourceDetailsVF_01.getUniqueId(), serviceDetails_01,
 764                                 sdncDesignerDetails);
 765                 assertEquals(404, deleteVFInstResp.getErrorCode().intValue());
 766         }
 767
 768         @Test
 769         public void deleteResourceInstanceWithEmptyResourceInstanceUidTest() throws Exception, Throwable {
 770                 RestResponse deleteVFInstResp = deleteVFInstance("", serviceDetails_01, sdncDesignerDetails);
 771                 assertEquals(405, deleteVFInstResp.getErrorCode().intValue());
 772                 getComponentAndValidateRIs(serviceDetails_01, 0, 0);
 773         }
 774
 775         @Test
 776         public void deleteResourceInstanceWithEmptyUserIdTest() throws Exception {
 777                 sdncDesignerDetails.setUserId("");
 778                 deleteVFInstanceFail(ActionStatus.RESTRICTED_OPERATION, new ArrayList<String>(), resourceDetailsVF_01,
 779                                 sdncDesignerDetails, 409);
 780                 deleteAtomicResourceInstanceFail(ActionStatus.RESTRICTED_OPERATION, new ArrayList<String>(),
 781                                 resourceDetailsCP_01, sdncDesignerDetails, 409);
 782                 getComponentAndValidateRIs(serviceDetails_01, 0, 0);
 783         }
 784
 785         // fail - bug DE188994
 786         @Test
 787         public void associateResourceInstanceToResourceInstanceNotFoundTest() throws Exception, Throwable {
 788                 RestResponse createVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_01,
 789                                 sdncDesignerDetails);
 790                 String reqCompInstId = ResponseParser.getUniqueIdFromResponse(createVFInstResp);
 791                 String capCompInstId = "1234";
 792
 793                 CapReqDef capReqDefBeforeAssociate = ComponentRestUtils
 794                                 .getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails, serviceDetails_01);
 795                 List<RequirementDefinition> reqListBeforeAssociate = capReqDefBeforeAssociate.getRequirements()
 796                                 .get(CAPABILITY_TYPE);
 797                 List<CapabilityDefinition> capListBeforeAssociate = new ArrayList<CapabilityDefinition>();
 798                 CapabilityDefinition cap = new CapabilityDefinition();
 799                 cap.setUniqueId(capCompInstId);
 800                 capListBeforeAssociate.add(cap);
 801                 RequirementCapabilityRelDef requirementDef = getReqCapRelation(reqCompInstId, capCompInstId, CAPABILITY_TYPE,
 802                                 REQUIREMENT_NAME, capListBeforeAssociate, reqListBeforeAssociate);
 803
 804                 assocaiteInstancesFail(requirementDef, sdncDesignerDetails, ActionStatus.RESOURCE_INSTANCE_NOT_FOUND, 404,
 805                                 new ArrayList<String>(Arrays.asList(capCompInstId)));
 806
 807                 CapReqDef capReqDefAfterAssociate = ComponentRestUtils
 808                                 .getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails, serviceDetails_01);
 809                 List<CapabilityDefinition> capabilitiesAfterAssociate = capReqDefAfterAssociate.getCapabilities()
 810                                 .get(CAPABILITY_TYPE);
 811                 List<RequirementDefinition> requirementsAfterAssoicate = capReqDefAfterAssociate.getRequirements()
 812                                 .get(CAPABILITY_TYPE);
 813                 // AssertJUnit.assertEquals("Check requirement", reqListBeforeAssociate,
 814                 // requirementsAfterAssoicate);
 815                 // AssertJUnit.assertEquals("Check requirement", capListBeforeAssociate,
 816                 // capabilitiesAfterAssociate);
 817
 818                 getComponentAndValidateRIs(serviceDetails_01, 1, 0);
 819
 820                 // "messageId": "SVC4116",
 821                 // "text": "Error: Invalid Content.",
 822                 // "variables": [
 823                 // "VF100 1",
 824                 // "9ae76786-2a9c-4409-95cb-db32885ed07f.eece8aaf-eb9f-4aff-b9a5-a11ca11de9e5.vf1001",
 825                 // "host"
 826                 // ]
 827         }
 828
 829         // this case is not relevant any more, it is tested as part of occurrences
 830         // story
 831         @Test(enabled = false)
 832         public void associateOnceAgainExistingRelationTest() throws Exception {
 833                 RestResponse createFirstVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_01,
 834                                 sdncDesignerDetails);
 835                 String reqCompInstId = ResponseParser.getUniqueIdFromResponse(createFirstVFInstResp);
 836                 RestResponse createSecondVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_02,
 837                                 sdncDesignerDetails);
 838                 String capCompInstId = ResponseParser.getUniqueIdFromResponse(createSecondVFInstResp);
 839
 840                 CapReqDef capReqDefBeforeAssociate = ComponentRestUtils
 841                                 .getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails, serviceDetails_01);
 842                 List<CapabilityDefinition> capListBeforeAssociate = capReqDefBeforeAssociate.getCapabilities()
 843                                 .get(CAPABILITY_TYPE);
 844                 List<RequirementDefinition> reqListBeforeAssociate = capReqDefBeforeAssociate.getRequirements()
 845                                 .get(CAPABILITY_TYPE);
 846
 847                 RequirementCapabilityRelDef requirementDef = getReqCapRelation(reqCompInstId, capCompInstId, CAPABILITY_TYPE,
 848                                 REQUIREMENT_NAME, capListBeforeAssociate, reqListBeforeAssociate);
 849
 850                 associateComponentInstancesForService(requirementDef, serviceDetails_01, sdncDesignerDetails);
 851                 //////////////////////////////////////////////
 852                 // NO ERROR - RELATION ALREADY EXIST
 853                 // assocaiteInstancesFail(requirementDef, sdncDesignerDetails,
 854                 // ActionStatus.RESOURCE_INSTANCE_NOT_FOUND, 404, new
 855                 // ArrayList<String>(Arrays.asList(capCompInstId)));
 856                 //////////////////////////////////////////////
 857
 858                 CapReqDef capReqDefAfterAssociate = ComponentRestUtils
 859                                 .getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails, serviceDetails_01);
 860                 List<CapabilityDefinition> capListAfterAssociate = capReqDefAfterAssociate.getCapabilities()
 861                                 .get(CAPABILITY_TYPE);
 862                 List<RequirementDefinition> reqListAfterAssociate = capReqDefAfterAssociate.getRequirements()
 863                                 .get(CAPABILITY_TYPE);
 864
 865                 // AssertJUnit.assertEquals("Check requirement", null,
 866                 // reqListAfterAssociate);
 867                 // AssertJUnit.assertEquals("Check requirement", capListBeforeAssociate,
 868                 // capListAfterAssociate);
 869
 870                 getComponentAndValidateRIs(serviceDetails_01, 2, 1);
 871
 872                 // "messageId": "SVC4119",
 873                 // "text": "Error: No relation found between resource instances
 874                 // \u0027%1\u0027 and \u0027%2\u0027 for requirement \u0027%3\u0027.",
 875                 // "variables": [
 876                 // "VF100 1",
 877                 // "VF_admin 2",
 878                 // "host"
 879
 880         }
 881
 882         @Test
 883         public void associateInstancesInMissingServiceTest() throws Exception {
 884                 serviceDetails_01.setUniqueId("1234");
 885                 RequirementCapabilityRelDef requirementDef = new RequirementCapabilityRelDef();
 886                 assocaiteInstancesFail(requirementDef, sdncDesignerDetails, ActionStatus.SERVICE_NOT_FOUND, 404,
 887                                 new ArrayList<String>(Arrays.asList("")));
 888         }
 889
 890         @Test
 891         public void associateAfterDeletingResourceTest() throws Exception {
 892                 RestResponse createFirstVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_01,
 893                                 sdncDesignerDetails);
 894                 String reqCompInstId = ResponseParser.getUniqueIdFromResponse(createFirstVFInstResp);
 895                 RestResponse createSecondVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_02,
 896                                 sdncDesignerDetails);
 897                 String capCompInstId = ResponseParser.getUniqueIdFromResponse(createSecondVFInstResp);
 898
 899                 CapReqDef capReqDefBeforeAssociate = ComponentRestUtils
 900                                 .getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails, serviceDetails_01);
 901                 List<CapabilityDefinition> capListBeforeAssociate = capReqDefBeforeAssociate.getCapabilities()
 902                                 .get(CAPABILITY_TYPE);
 903                 List<RequirementDefinition> reqListBeforeAssociate = capReqDefBeforeAssociate.getRequirements()
 904                                 .get(CAPABILITY_TYPE);
 905
 906                 RequirementCapabilityRelDef requirementDef = getReqCapRelation(reqCompInstId, capCompInstId, CAPABILITY_TYPE,
 907                                 REQUIREMENT_NAME, capListBeforeAssociate, reqListBeforeAssociate);
 908
 909                 ResourceRestUtils.deleteResource(resourceDetailsVF_01.getUniqueId(), sdncDesignerDetails.getUserId());
 910
 911                 associateComponentInstancesForService(requirementDef, serviceDetails_01, sdncDesignerDetails);
 912                 CapReqDef capReqDefAfterAssociate = ComponentRestUtils
 913                                 .getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails, serviceDetails_01);
 914                 List<CapabilityDefinition> capListAfterAssociate = capReqDefAfterAssociate.getCapabilities()
 915                                 .get(CAPABILITY_TYPE);
 916
 917                 // for (CapabilityDefinition capabilityDefinition :
 918                 // capListBeforeAssociate) {
 919                 // if (capabilityDefinition.getType().equals(CAPABILITY_TYPE)){
 920                 // capabilityDefinition.setMinOccurrences("0");
 921                 // }
 922                 // }
 923                 //
 924                 // List<RequirementDefinition> reqListAfterAssociate =
 925                 // capReqDefAfterAssociate.getRequirements().get(CAPABILITY_TYPE);
 926                 //
 927                 // AssertJUnit.assertEquals("Check requirement", null,
 928                 // reqListAfterAssociate);
 929                 //
 930                 // AssertJUnit.assertEquals("Check requirement", capListBeforeAssociate,
 931                 // capListAfterAssociate);
 932
 933                 getComponentAndValidateRIs(serviceDetails_01, 2, 1);
 934         }
 935
 936         @Test
 937         public void associateInstancesInCheckedinServiceTest() throws Exception {
 938                 RestResponse createFirstVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_01,
 939                                 sdncDesignerDetails);
 940                 String reqCompInstId = ResponseParser.getUniqueIdFromResponse(createFirstVFInstResp);
 941                 RestResponse createSecondVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_02,
 942                                 sdncDesignerDetails);
 943                 String capCompInstId = ResponseParser.getUniqueIdFromResponse(createSecondVFInstResp);
 944
 945                 CapReqDef capReqDefBeforeAssociate = ComponentRestUtils
 946                                 .getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails, serviceDetails_01);
 947                 List<CapabilityDefinition> capListBeforeAssociate = capReqDefBeforeAssociate.getCapabilities()
 948                                 .get(CAPABILITY_TYPE);
 949                 List<RequirementDefinition> reqListBeforeAssociate = capReqDefBeforeAssociate.getRequirements()
 950                                 .get(CAPABILITY_TYPE);
 951
 952                 RequirementCapabilityRelDef requirementDef = getReqCapRelation(reqCompInstId, capCompInstId, CAPABILITY_TYPE,
 953                                 REQUIREMENT_NAME, capListBeforeAssociate, reqListBeforeAssociate);
 954
 955                 changeServiceLifecycleState(serviceDetails_01, sdncDesignerDetails, LifeCycleStatesEnum.CHECKIN);
 956
 957                 assocaiteInstancesFail(requirementDef, sdncDesignerDetails, ActionStatus.RESTRICTED_OPERATION, 409,
 958                                 new ArrayList<String>());
 959
 960                 CapReqDef capReqDefAfterAssociate = ComponentRestUtils
 961                                 .getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails, serviceDetails_01);
 962                 List<CapabilityDefinition> capabilitiesAfterAssociate = capReqDefAfterAssociate.getCapabilities()
 963                                 .get(CAPABILITY_TYPE);
 964                 List<RequirementDefinition> requirementsAfterAssoicate = capReqDefAfterAssociate.getRequirements()
 965                                 .get(CAPABILITY_TYPE);
 966                 AssertJUnit.assertEquals("Check requirement", reqListBeforeAssociate, requirementsAfterAssoicate);
 967                 AssertJUnit.assertEquals("Check requirement", capListBeforeAssociate, capabilitiesAfterAssociate);
 968
 969                 getComponentAndValidateRIs(serviceDetails_01, 2, 0);
 970         }
 971
 972         // fail - bug DE188994
 973         @Test
 974         public void associateAfterCheckoutAllInstancesTest() throws Exception {
 975                 String firstVFUniqueId = resourceDetailsVF_01.getUniqueId();
 976                 RestResponse createFirstVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_01,
 977                                 sdncDesignerDetails);
 978                 String reqCompInstId = ResponseParser.getUniqueIdFromResponse(createFirstVFInstResp);
 979                 String secondVFUniqueId = resourceDetailsVF_02.getUniqueId();
 980                 RestResponse createSecondVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_02,
 981                                 sdncDesignerDetails);
 982                 String capCompInstId = ResponseParser.getUniqueIdFromResponse(createSecondVFInstResp);
 983
 984                 CapReqDef capReqDefBeforeAssociate = ComponentRestUtils
 985                                 .getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails, serviceDetails_01);
 986                 List<CapabilityDefinition> capListBeforeAssociate = capReqDefBeforeAssociate.getCapabilities()
 987                                 .get(CAPABILITY_TYPE);
 988                 List<RequirementDefinition> reqListBeforeAssociate = capReqDefBeforeAssociate.getRequirements()
 989                                 .get(CAPABILITY_TYPE);
 990
 991                 RequirementCapabilityRelDef requirementDef = getReqCapRelation(reqCompInstId, capCompInstId, CAPABILITY_TYPE,
 992                                 REQUIREMENT_NAME, capListBeforeAssociate, reqListBeforeAssociate);
 993
 994                 changeResourceLifecycleState(resourceDetailsVF_01, sdncDesignerDetails.getUserId(),
 995                                 LifeCycleStatesEnum.CHECKOUT);
 996                 changeResourceLifecycleState(resourceDetailsVF_02, sdncDesignerDetails.getUserId(),
 997                                 LifeCycleStatesEnum.CHECKOUT);
 998
 999                 requirementDef.setFromNode(
1000                                 requirementDef.getFromNode().replaceAll(firstVFUniqueId, resourceDetailsVF_01.getUniqueId()));
1001                 requirementDef
1002                                 .setToNode(requirementDef.getToNode().replaceAll(secondVFUniqueId, resourceDetailsVF_02.getUniqueId()));
1003
1004                 assocaiteInstancesFail(requirementDef, sdncDesignerDetails, ActionStatus.RESTRICTED_OPERATION, 409,
1005                                 new ArrayList<String>());
1006
1007                 CapReqDef capReqDefAfterAssociate = ComponentRestUtils
1008                                 .getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails, serviceDetails_01);
1009                 List<CapabilityDefinition> capabilitiesAfterAssociate = capReqDefAfterAssociate.getCapabilities()
1010                                 .get(CAPABILITY_TYPE);
1011                 List<RequirementDefinition> requirementsAfterAssoicate = capReqDefAfterAssociate.getRequirements()
1012                                 .get(CAPABILITY_TYPE);
1013                 // AssertJUnit.assertEquals("Check requirement", reqListBeforeAssociate,
1014                 // requirementsAfterAssoicate);
1015                 // AssertJUnit.assertEquals("Check requirement", capListBeforeAssociate,
1016                 // capabilitiesAfterAssociate);
1017
1018                 getComponentAndValidateRIs(serviceDetails_01, 2, 0);
1019
1020                 // "messageId": "SVC4116",
1021                 // "text": "Error: Invalid Content.",
1022                 // "variables": [
1023                 // "e9dcea15-ce27-4381-a554-4278973cefb1.d0b3affd-cf92-4626-adfe-961b44103924.vf1001",
1024                 // "e9dcea15-ce27-4381-a554-4278973cefb1.d0b3affd-cf92-4626-adfe-961b44103924.vf1001",
1025                 // "host"
1026                 // ]
1027
1028         }
1029
1030         @Test
1031         public void associateInstancesByDifferentUsersTest() throws Exception {
1032                 RestResponse createFirstVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_01,
1033                                 sdncDesignerDetails);
1034                 String reqCompInstId = ResponseParser.getUniqueIdFromResponse(createFirstVFInstResp);
1035                 RestResponse createSecondVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_02,
1036                                 sdncDesignerDetails);
1037                 String capCompInstId = ResponseParser.getUniqueIdFromResponse(createSecondVFInstResp);
1038
1039                 CapReqDef capReqDefBeforeAssociate = ComponentRestUtils
1040                                 .getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails, serviceDetails_01);
1041                 List<CapabilityDefinition> capListBeforeAssociate = capReqDefBeforeAssociate.getCapabilities()
1042                                 .get(CAPABILITY_TYPE);
1043                 List<RequirementDefinition> reqListBeforeAssociate = capReqDefBeforeAssociate.getRequirements()
1044                                 .get(CAPABILITY_TYPE);
1045
1046                 RequirementCapabilityRelDef requirementDef = getReqCapRelation(reqCompInstId, capCompInstId, CAPABILITY_TYPE,
1047                                 REQUIREMENT_NAME, capListBeforeAssociate, reqListBeforeAssociate);
1048
1049                 assocaiteInstancesFail(requirementDef, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER2),
1050                                 ActionStatus.RESTRICTED_OPERATION, 409, new ArrayList<String>());
1051                 assocaiteInstancesFail(requirementDef, ElementFactory.getDefaultUser(UserRoleEnum.TESTER),
1052                                 ActionStatus.RESTRICTED_OPERATION, 409, new ArrayList<String>());
1053                 assocaiteInstancesFail(requirementDef, ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR),
1054                                 ActionStatus.RESTRICTED_OPERATION, 409, new ArrayList<String>());
1055                 assocaiteInstancesFail(requirementDef, ElementFactory.getDefaultUser(UserRoleEnum.OPS),
1056                                 ActionStatus.RESTRICTED_OPERATION, 409, new ArrayList<String>());
1057                 assocaiteInstancesFail(requirementDef, ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1),
1058                                 ActionStatus.RESTRICTED_OPERATION, 409, new ArrayList<String>());
1059
1060                 CapReqDef capReqDefAfterAssociate = ComponentRestUtils
1061                                 .getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails, serviceDetails_01);
1062                 List<CapabilityDefinition> capabilitiesAfterAssociate = capReqDefAfterAssociate.getCapabilities()
1063                                 .get(CAPABILITY_TYPE);
1064                 List<RequirementDefinition> requirementsAfterAssoicate = capReqDefAfterAssociate.getRequirements()
1065                                 .get(CAPABILITY_TYPE);
1066                 AssertJUnit.assertEquals("Check requirement", reqListBeforeAssociate, requirementsAfterAssoicate);
1067                 AssertJUnit.assertEquals("Check requirement", capListBeforeAssociate, capabilitiesAfterAssociate);
1068
1069                 getComponentAndValidateRIs(serviceDetails_01, 2, 0);
1070         }
1071
1072         private void assocaiteInstancesFail(RequirementCapabilityRelDef requirementDef, User user,
1073                         ActionStatus actionStatus, int errorCode, List<String> variables) throws IOException, Exception {
1074                 RestResponse associateInstancesResp = ComponentInstanceRestUtils.associateInstances(requirementDef, user,
1075                                 serviceDetails_01.getUniqueId(), ComponentTypeEnum.SERVICE);
1076                 checkErrorMessage(actionStatus, variables, errorCode, associateInstancesResp);
1077         }
1078
1079         private void dissoicateInstancesFail(RequirementCapabilityRelDef requirementDef, User user,
1080                         ActionStatus actionStatus, int errorCode, List<String> variables) throws IOException, Exception {
1081                 RestResponse dissoicateInstancesResp = ComponentInstanceRestUtils.dissociateInstances(requirementDef, user,
1082                                 serviceDetails_01.getUniqueId(), ComponentTypeEnum.SERVICE);
1083                 checkErrorMessage(actionStatus, variables, errorCode, dissoicateInstancesResp);
1084         }
1085
1086         @Test
1087         public void associateWithMissingServiceUidTest() throws Exception {
1088                 RequirementCapabilityRelDef requirementDef = new RequirementCapabilityRelDef();
1089                 serviceDetails_01.setUniqueId("");
1090                 RestResponse associateInstancesResp = ComponentInstanceRestUtils.associateInstances(requirementDef,
1091                                 sdncDesignerDetails, serviceDetails_01.getUniqueId(), ComponentTypeEnum.SERVICE);
1092                 assertEquals(404, associateInstancesResp.getErrorCode().intValue());
1093         }
1094
1095         // fail - bug DE191824
1096         @Test
1097         public void associateNotCompitableReqCapTest() throws Exception {
1098                 RestResponse createFirstAtomicResourceInstResp = createCheckedinAtomicInstanceForService(serviceDetails_01,
1099                                 resourceDetailsCP_01, sdncDesignerDetails);
1100                 String reqCompInstName = ResponseParser.getNameFromResponse(createFirstAtomicResourceInstResp);
1101                 String reqCompInstId = ResponseParser.getUniqueIdFromResponse(createFirstAtomicResourceInstResp);
1102                 RestResponse createSecondAtomicResourceInstResp = createCheckedinAtomicInstanceForService(serviceDetails_01,
1103                                 resourceDetailsVL_02, sdncDesignerDetails);
1104                 String capCompInstName = ResponseParser.getNameFromResponse(createSecondAtomicResourceInstResp);
1105                 String capCompInstId = ResponseParser.getUniqueIdFromResponse(createSecondAtomicResourceInstResp);
1106
1107                 CapReqDef capReqDefBeforeAssociate = ComponentRestUtils
1108                                 .getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails, serviceDetails_01);
1109                 List<CapabilityDefinition> capListBeforeAssociate = capReqDefBeforeAssociate.getCapabilities()
1110                                 .get(CAPABILITY_TYPE);
1111                 List<RequirementDefinition> reqListBeforeAssociate = capReqDefBeforeAssociate.getRequirements()
1112                                 .get(CAPABILITY_TYPE);
1113
1114                 RequirementCapabilityRelDef requirementDef = getReqCapRelation(reqCompInstId, capCompInstId, CAPABILITY_TYPE,
1115                                 REQUIREMENT_NAME, capListBeforeAssociate, reqListBeforeAssociate);
1116
1117                 List<String> variables = new ArrayList<String>();
1118                 variables.add(reqCompInstName);
1119                 variables.add(capCompInstName);
1120                 variables.add(REQUIREMENT_NAME);
1121
1122                 assocaiteInstancesFail(requirementDef, sdncDesignerDetails, ActionStatus.RESOURCE_INSTANCE_MATCH_NOT_FOUND, 404,
1123                                 variables);
1124
1125                 CapReqDef capReqDefAfterAssociate = ComponentRestUtils
1126                                 .getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails, serviceDetails_01);
1127                 List<CapabilityDefinition> capabilitiesAfterAssociate = capReqDefAfterAssociate.getCapabilities()
1128                                 .get(CAPABILITY_TYPE);
1129                 List<RequirementDefinition> requirementsAfterAssoicate = capReqDefAfterAssociate.getRequirements()
1130                                 .get(CAPABILITY_TYPE);
1131                 // AssertJUnit.assertEquals("Check requirement", reqListBeforeAssociate,
1132                 // requirementsAfterAssoicate);
1133                 // AssertJUnit.assertEquals("Check requirement", capListBeforeAssociate,
1134                 // capabilitiesAfterAssociate);
1135
1136                 getComponentAndValidateRIs(serviceDetails_01, 2, 0);
1137
1138                 // {"requestError":{"serviceException":{"messageId":"SVC4119","text":"Error:
1139                 // No relation found between resource instances '%1' and '%2' for
1140                 // requirement '%3'.","variables":["CP100 1","VL200 2","host"]}}}>
1141         }
1142
1143         @Test
1144         public void associateInstancesInTwoServiceVersionsTest() throws Exception {
1145                 String oldServiceUniqueId = serviceDetails_01.getUniqueId();
1146                 RestResponse createFirstVFInstResp = createVFInstance(serviceDetails_01, resourceDetailsVF_01,
1147                                 sdncDesignerDetails);
1148                 String reqCompInstId = ResponseParser.getUniqueIdFromResponse(createFirstVFInstResp);
1149                 RestResponse createSecondVFInstResp = createVFInstance(serviceDetails_01, resourceDetailsVF_02,
1150                                 sdncDesignerDetails);
1151                 String capCompInstId = ResponseParser.getUniqueIdFromResponse(createSecondVFInstResp);
1152
1153                 CapReqDef capReqDefBeforeAssociate = ComponentRestUtils
1154                                 .getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails, serviceDetails_01);
1155                 List<CapabilityDefinition> capListBeforeAssociate = capReqDefBeforeAssociate.getCapabilities()
1156                                 .get(CAPABILITY_TYPE);
1157                 List<RequirementDefinition> reqListBeforeAssociate = capReqDefBeforeAssociate.getRequirements()
1158                                 .get(CAPABILITY_TYPE);
1159
1160                 RequirementCapabilityRelDef requirementDef = getReqCapRelation(reqCompInstId, capCompInstId, CAPABILITY_TYPE,
1161                                 REQUIREMENT_NAME, capListBeforeAssociate, reqListBeforeAssociate);
1162                 associateComponentInstancesForService(requirementDef, serviceDetails_01, sdncDesignerDetails);
1163                 getComponentAndValidateRIs(serviceDetails_01, 2, 1);
1164
1165                 changeServiceLifecycleState(serviceDetails_01, sdncDesignerDetails, LifeCycleStatesEnum.CHECKIN);
1166                 changeServiceLifecycleState(serviceDetails_01, sdncDesignerDetails, LifeCycleStatesEnum.CHECKOUT);
1167                 String secondServiceUniqueId = serviceDetails_01.getUniqueId();
1168
1169                 serviceDetails_01.setUniqueId(oldServiceUniqueId);
1170                 getComponentAndValidateRIs(serviceDetails_01, 2, 1);
1171
1172                 updateCapabilitiesOwnerId(oldServiceUniqueId, capListBeforeAssociate, secondServiceUniqueId);
1173                 updateExpectedReqCapAfterChangeLifecycleState(oldServiceUniqueId, secondServiceUniqueId);
1174                 CapReqDef capReqDefAfterAssociate = ComponentRestUtils
1175                                 .getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails, serviceDetails_01);
1176                 List<CapabilityDefinition> capListAfterAssociate = capReqDefAfterAssociate.getCapabilities()
1177                                 .get(CAPABILITY_TYPE);
1178                 List<RequirementDefinition> reqListAfterAssociate = capReqDefAfterAssociate.getRequirements()
1179                                 .get(CAPABILITY_TYPE);
1180                 // AssertJUnit.assertEquals("Check requirement", null,
1181                 // reqListAfterAssociate);
1182                 // AssertJUnit.assertEquals("Check capabilities",
1183                 // capListBeforeAssociate, capListAfterAssociate);
1184                 getComponentAndValidateRIs(serviceDetails_01, 2, 1);
1185
1186                 RestResponse createThirdVFInstResp = createVFInstance(serviceDetails_01, resourceDetailsVF_01,
1187                                 sdncDesignerDetails);
1188                 String reqSecondCompInstId = ResponseParser.getUniqueIdFromResponse(createThirdVFInstResp);
1189
1190                 CapReqDef capReqDefBeforeSeconderyAssociate = ComponentRestUtils
1191                                 .getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails, serviceDetails_01);
1192                 List<CapabilityDefinition> capListBeforeSeconderyAssociate = capReqDefBeforeSeconderyAssociate.getCapabilities()
1193                                 .get(CAPABILITY_TYPE);
1194                 List<RequirementDefinition> reqListBeforeSeconderyAssociate = capReqDefBeforeSeconderyAssociate
1195                                 .getRequirements().get(CAPABILITY_TYPE);
1196
1197                 capCompInstId = capCompInstId.replaceAll(oldServiceUniqueId, secondServiceUniqueId);
1198                 RequirementCapabilityRelDef secondRequirementDef = getReqCapRelation(reqSecondCompInstId, capCompInstId,
1199                                 CAPABILITY_TYPE, REQUIREMENT_NAME, capListBeforeSeconderyAssociate, reqListBeforeSeconderyAssociate);
1200                 associateComponentInstancesForService(secondRequirementDef, serviceDetails_01, sdncDesignerDetails);
1201
1202                 CapReqDef capReqDefAfterSeconderyAssociate = ComponentRestUtils
1203                                 .getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails, serviceDetails_01);
1204                 List<CapabilityDefinition> capListAfterSeconderyAssociate = capReqDefAfterSeconderyAssociate.getCapabilities()
1205                                 .get(CAPABILITY_TYPE);
1206                 List<RequirementDefinition> reqListAfterSeconderyAssociate = capReqDefAfterSeconderyAssociate.getRequirements()
1207                                 .get(CAPABILITY_TYPE);
1208                 // AssertJUnit.assertEquals("Check requirement", null,
1209                 // reqListAfterSeconderyAssociate);
1210                 // AssertJUnit.assertEquals("Check capabilities",
1211                 // capListBeforeAssociate, capListAfterSeconderyAssociate);
1212                 getComponentAndValidateRIs(serviceDetails_01, 3, 2);
1213         }
1214
1215         private void updateCapabilitiesOwnerId(String oldUniqueId, List<CapabilityDefinition> capList, String newUniqueId) {
1216                 serviceDetails_01.setUniqueId(newUniqueId);
1217                 for (CapabilityDefinition cap : capList) {
1218                         String oldOwnerId = cap.getOwnerId();
1219                         String newOwnerId = oldOwnerId.replaceAll(oldUniqueId, newUniqueId);
1220                         cap.setOwnerId(newOwnerId);
1221                 }
1222         }
1223
1224         @Test
1225         public void dissociateRelationNotFoundTest() throws Exception {
1226                 createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_01, sdncDesignerDetails);
1227                 String reqCompInstId = "1234";
1228                 createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_02, sdncDesignerDetails);
1229                 String capCompInstId = "4567";
1230
1231                 CapReqDef capReqDef = ComponentRestUtils.getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails,
1232                                 serviceDetails_01);
1233                 List<CapabilityDefinition> capList = capReqDef.getCapabilities().get(CAPABILITY_TYPE);
1234                 List<RequirementDefinition> reqList = capReqDef.getRequirements().get(CAPABILITY_TYPE);
1235
1236                 RequirementCapabilityRelDef requirementDef = getReqCapRelation(reqCompInstId, capCompInstId, CAPABILITY_TYPE,
1237                                 REQUIREMENT_NAME, capList, reqList);
1238
1239                 List<String> variables = new ArrayList<String>();
1240                 variables.add(reqCompInstId);
1241                 variables.add(capCompInstId);
1242                 variables.add(REQUIREMENT_NAME);
1243                 dissoicateInstancesFail(requirementDef, sdncDesignerDetails, ActionStatus.RESOURCE_INSTANCE_RELATION_NOT_FOUND,
1244                                 404, variables);
1245
1246                 CapReqDef capReqDefAfterDissociate = ComponentRestUtils
1247                                 .getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails, serviceDetails_01);
1248                 List<CapabilityDefinition> capListAfterDissociate = capReqDefAfterDissociate.getCapabilities()
1249                                 .get(CAPABILITY_TYPE);
1250                 List<RequirementDefinition> reqListAfterDissociate = capReqDefAfterDissociate.getRequirements()
1251                                 .get(CAPABILITY_TYPE);
1252
1253                 AssertJUnit.assertEquals("Check requirement", 1, reqListAfterDissociate.size());
1254                 AssertJUnit.assertEquals("Check requirement", reqList, reqListAfterDissociate);
1255                 AssertJUnit.assertEquals("Check capabilities", capList, capListAfterDissociate);
1256
1257                 getComponentAndValidateRIs(serviceDetails_01, 2, 0);
1258
1259         }
1260
1261         @Test
1262         public void dissociateRelationInServiceNotFoundTest() throws Exception {
1263                 String uniqueId = "1234";
1264                 RestResponse createFirstVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_01,
1265                                 sdncDesignerDetails);
1266                 String reqCompInstId = ResponseParser.getUniqueIdFromResponse(createFirstVFInstResp);
1267                 RestResponse createSecondVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_02,
1268                                 sdncDesignerDetails);
1269                 String capCompInstId = ResponseParser.getUniqueIdFromResponse(createSecondVFInstResp);
1270
1271                 CapReqDef capReqDefBeforeAssociate = ComponentRestUtils
1272                                 .getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails, serviceDetails_01);
1273                 List<CapabilityDefinition> capListBeforeAssociate = capReqDefBeforeAssociate.getCapabilities()
1274                                 .get(CAPABILITY_TYPE);
1275                 List<RequirementDefinition> reqListBeforeAssociate = capReqDefBeforeAssociate.getRequirements()
1276                                 .get(CAPABILITY_TYPE);
1277
1278                 RequirementCapabilityRelDef requirementDef = getReqCapRelation(reqCompInstId, capCompInstId, CAPABILITY_TYPE,
1279                                 REQUIREMENT_NAME, capListBeforeAssociate, reqListBeforeAssociate);
1280
1281                 serviceDetails_01.setUniqueId(uniqueId);
1282                 dissoicateInstancesFail(requirementDef, sdncDesignerDetails, ActionStatus.SERVICE_NOT_FOUND, 404,
1283                                 new ArrayList<String>(Arrays.asList("")));
1284
1285         }
1286
1287         @Test
1288         public void dissoicateRelationWhileInstanceNotFound() throws Exception {
1289                 String capUniqueId = "1234";
1290
1291                 RestResponse createFirstVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_01,
1292                                 sdncDesignerDetails);
1293                 String reqCompInstId = ResponseParser.getUniqueIdFromResponse(createFirstVFInstResp);
1294                 createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_02, sdncDesignerDetails);
1295                 String capCompInstId = capUniqueId;
1296
1297                 CapReqDef capReqDefBeforeAssociate = ComponentRestUtils
1298                                 .getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails, serviceDetails_01);
1299                 List<CapabilityDefinition> capListBeforeAssociate = capReqDefBeforeAssociate.getCapabilities()
1300                                 .get(CAPABILITY_TYPE);
1301                 List<RequirementDefinition> reqListBeforeAssociate = capReqDefBeforeAssociate.getRequirements()
1302                                 .get(CAPABILITY_TYPE);
1303
1304                 RequirementCapabilityRelDef requirementDef = getReqCapRelation(reqCompInstId, capCompInstId, CAPABILITY_TYPE,
1305                                 REQUIREMENT_NAME, capListBeforeAssociate, reqListBeforeAssociate);
1306
1307                 List<String> variables = new ArrayList<String>();
1308                 variables.add(reqCompInstId);
1309                 variables.add(capCompInstId);
1310                 variables.add(REQUIREMENT_NAME);
1311                 dissoicateInstancesFail(requirementDef, sdncDesignerDetails, ActionStatus.RESOURCE_INSTANCE_RELATION_NOT_FOUND,
1312                                 404, variables);
1313
1314                 CapReqDef capReqDefAfterDissociate = ComponentRestUtils
1315                                 .getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails, serviceDetails_01);
1316                 List<CapabilityDefinition> capListAfterDissociate = capReqDefAfterDissociate.getCapabilities()
1317                                 .get(CAPABILITY_TYPE);
1318                 List<RequirementDefinition> reqListAfterDissociate = capReqDefAfterDissociate.getRequirements()
1319                                 .get(CAPABILITY_TYPE);
1320                 AssertJUnit.assertEquals("Check requirement", reqListBeforeAssociate, reqListAfterDissociate);
1321                 AssertJUnit.assertEquals("Check capabilities", capListBeforeAssociate, capListAfterDissociate);
1322
1323                 getComponentAndValidateRIs(serviceDetails_01, 2, 0);
1324         }
1325
1326         @Test
1327         public void dissociateWhileServiceCheckedinTest() throws Exception {
1328                 changeServiceLifecycleState(serviceDetails_01, sdncDesignerDetails, LifeCycleStatesEnum.CHECKIN);
1329                 RequirementCapabilityRelDef requirementDef = new RequirementCapabilityRelDef();
1330                 dissoicateInstancesFail(requirementDef, sdncDesignerDetails, ActionStatus.RESTRICTED_OPERATION, 409,
1331                                 new ArrayList<String>());
1332         }
1333
1334         @Test
1335         public void dissoicateWithEmptyUserIdHeaderTest() throws Exception {
1336                 sdncDesignerDetails.setUserId("");
1337                 RequirementCapabilityRelDef requirementDef = new RequirementCapabilityRelDef();
1338                 dissoicateInstancesFail(requirementDef, sdncDesignerDetails, ActionStatus.RESTRICTED_OPERATION, 409,
1339                                 new ArrayList<String>());
1340         }
1341
1342         @Test
1343         public void dissociateWithMissingUidOfServiceTest() throws Exception {
1344                 serviceDetails_01.setUniqueId("");
1345                 RequirementCapabilityRelDef requirementDef = new RequirementCapabilityRelDef();
1346                 RestResponse dissociateResp = ComponentInstanceRestUtils.dissociateInstances(requirementDef,
1347                                 sdncDesignerDetails, serviceDetails_01.getUniqueId(), ComponentTypeEnum.SERVICE);
1348                 assertEquals(404, dissociateResp.getErrorCode().intValue());
1349         }
1350
1351         @Test
1352         public void relationDeletedAfterDeletingResourceInstanceTest() throws Exception {
1353                 RestResponse createFirstVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_01,
1354                                 sdncDesignerDetails);
1355                 String reqCompInstId = ResponseParser.getUniqueIdFromResponse(createFirstVFInstResp);
1356                 RestResponse createSecondVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_02,
1357                                 sdncDesignerDetails);
1358                 String capCompInstId = ResponseParser.getUniqueIdFromResponse(createSecondVFInstResp);
1359
1360                 CapReqDef capReqDefBeforeAssociate = ComponentRestUtils
1361                                 .getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails, serviceDetails_01);
1362                 List<CapabilityDefinition> capListBeforeAssociate = capReqDefBeforeAssociate.getCapabilities()
1363                                 .get(CAPABILITY_TYPE);
1364                 List<RequirementDefinition> reqListBeforeAssociate = capReqDefBeforeAssociate.getRequirements()
1365                                 .get(CAPABILITY_TYPE);
1366
1367                 RequirementCapabilityRelDef requirementDef = getReqCapRelation(reqCompInstId, capCompInstId, CAPABILITY_TYPE,
1368                                 REQUIREMENT_NAME, capListBeforeAssociate, reqListBeforeAssociate);
1369
1370                 associateComponentInstancesForService(requirementDef, serviceDetails_01, sdncDesignerDetails);
1371                 getComponentAndValidateRIs(serviceDetails_01, 2, 1);
1372
1373                 RestResponse deleteVFInstance = deleteVFInstance(reqCompInstId, serviceDetails_01, sdncDesignerDetails);
1374                 ComponentInstanceRestUtils.checkDeleteResponse(deleteVFInstance);
1375                 getComponentAndValidateRIs(serviceDetails_01, 1, 0);
1376         }
1377
1378         @Test
1379         public void relationNotFoundInSecondVersionAfterDissociateTest() throws Exception {
1380                 String oldContainerUniqueIdToReplace = serviceDetails_01.getUniqueId();
1381                 RestResponse createFirstVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_01,
1382                                 sdncDesignerDetails);
1383                 String reqCompInstId = ResponseParser.getUniqueIdFromResponse(createFirstVFInstResp);
1384                 RestResponse createSecondVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_02,
1385                                 sdncDesignerDetails);
1386                 String capCompInstId = ResponseParser.getUniqueIdFromResponse(createSecondVFInstResp);
1387
1388                 CapReqDef capReqDefBeforeAssociate = ComponentRestUtils
1389                                 .getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails, serviceDetails_01);
1390                 List<CapabilityDefinition> capListBeforeAssociate = capReqDefBeforeAssociate.getCapabilities()
1391                                 .get(CAPABILITY_TYPE);
1392                 List<RequirementDefinition> reqListBeforeAssociate = capReqDefBeforeAssociate.getRequirements()
1393                                 .get(CAPABILITY_TYPE);
1394
1395                 RequirementCapabilityRelDef requirementDef = getReqCapRelation(reqCompInstId, capCompInstId, CAPABILITY_TYPE,
1396                                 REQUIREMENT_NAME, capListBeforeAssociate, reqListBeforeAssociate);
1397
1398                 associateComponentInstancesForService(requirementDef, serviceDetails_01, sdncDesignerDetails);
1399                 dissociateComponentInstancesForService(requirementDef, serviceDetails_01, sdncDesignerDetails);
1400
1401                 changeServiceLifecycleState(serviceDetails_01, sdncDesignerDetails, LifeCycleStatesEnum.CHECKIN);
1402                 changeServiceLifecycleState(serviceDetails_01, sdncDesignerDetails, LifeCycleStatesEnum.CHECKOUT);
1403
1404                 updateExpectedReqCapAfterChangeLifecycleState(oldContainerUniqueIdToReplace, serviceDetails_01.getUniqueId());
1405                 getComponentAndValidateRIs(serviceDetails_01, 2, 0);
1406         }
1407
1408         @Test
1409         public void dissociateOnceAgainTest() throws Exception {
1410                 RestResponse createFirstVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_01,
1411                                 sdncDesignerDetails);
1412                 String reqCompInstId = ResponseParser.getUniqueIdFromResponse(createFirstVFInstResp);
1413                 String reqCompInsName = ResponseParser
1414                                 .convertComponentInstanceResponseToJavaObject(createFirstVFInstResp.getResponse()).getName();
1415                 RestResponse createSecondVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_02,
1416                                 sdncDesignerDetails);
1417                 String capCompInstId = ResponseParser.getUniqueIdFromResponse(createSecondVFInstResp);
1418                 String capCompInstName = ResponseParser
1419                                 .convertComponentInstanceResponseToJavaObject(createSecondVFInstResp.getResponse()).getName();
1420
1421                 CapReqDef capReqDefBeforeAssociate = ComponentRestUtils
1422                                 .getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails, serviceDetails_01);
1423                 List<CapabilityDefinition> capListBeforeAssociate = capReqDefBeforeAssociate.getCapabilities()
1424                                 .get(CAPABILITY_TYPE);
1425                 List<RequirementDefinition> reqListBeforeAssociate = capReqDefBeforeAssociate.getRequirements()
1426                                 .get(CAPABILITY_TYPE);
1427
1428                 RequirementCapabilityRelDef requirementDef = getReqCapRelation(reqCompInstId, capCompInstId, CAPABILITY_TYPE,
1429                                 REQUIREMENT_NAME, capListBeforeAssociate, reqListBeforeAssociate);
1430
1431                 associateComponentInstancesForService(requirementDef, serviceDetails_01, sdncDesignerDetails);
1432                 dissociateComponentInstancesForService(requirementDef, serviceDetails_01, sdncDesignerDetails);
1433
1434                 List<String> variables = new ArrayList<String>();
1435                 variables.add(reqCompInsName);
1436                 variables.add(capCompInstName);
1437                 variables.add(REQUIREMENT_NAME);
1438
1439                 dissoicateInstancesFail(requirementDef, sdncDesignerDetails, ActionStatus.RESOURCE_INSTANCE_RELATION_NOT_FOUND,
1440                                 404, variables);
1441         }
1442
1443         // fail - bug : DE191707
1444         @Test
1445         public void associateTwoRelations_CheckinCheckout_DissoicateOneRelationInSecondVersion() throws Exception {
1446                 String oldContainerUniqueIdToReplace = serviceDetails_01.getUniqueId();
1447                 RestResponse createFirstVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_01,
1448                                 sdncDesignerDetails);
1449                 String reqCompInstId = ResponseParser.getUniqueIdFromResponse(createFirstVFInstResp);
1450                 RestResponse createSecondVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_02,
1451                                 sdncDesignerDetails);
1452                 String capCompInstId = ResponseParser.getUniqueIdFromResponse(createSecondVFInstResp);
1453                 RestResponse createThirdVFInstResp = createVFInstance(serviceDetails_01, resourceDetailsVF_01,
1454                                 sdncDesignerDetails);
1455                 String secondReqCompInstId = ResponseParser.getUniqueIdFromResponse(createThirdVFInstResp);
1456
1457                 CapReqDef capReqDefBeforeAssociate = ComponentRestUtils
1458                                 .getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails, serviceDetails_01);
1459                 List<CapabilityDefinition> capListBeforeAssociate = capReqDefBeforeAssociate.getCapabilities()
1460                                 .get(CAPABILITY_TYPE);
1461                 List<RequirementDefinition> reqListBeforeAssociate = capReqDefBeforeAssociate.getRequirements()
1462                                 .get(CAPABILITY_TYPE);
1463
1464                 RequirementCapabilityRelDef requirementDefFirstRelation = getReqCapRelation(reqCompInstId, capCompInstId,
1465                                 CAPABILITY_TYPE, REQUIREMENT_NAME, capListBeforeAssociate, reqListBeforeAssociate);
1466                 RequirementCapabilityRelDef requirementDefSecondRelation = getReqCapRelation(secondReqCompInstId, capCompInstId,
1467                                 CAPABILITY_TYPE, REQUIREMENT_NAME, capListBeforeAssociate, reqListBeforeAssociate);
1468
1469                 associateComponentInstancesForService(requirementDefFirstRelation, serviceDetails_01, sdncDesignerDetails);
1470                 associateComponentInstancesForService(requirementDefSecondRelation, serviceDetails_01, sdncDesignerDetails);
1471                 getComponentAndValidateRIs(serviceDetails_01, 3, 2);
1472
1473                 changeServiceLifecycleState(serviceDetails_01, sdncDesignerDetails, LifeCycleStatesEnum.CHECKIN);
1474                 changeServiceLifecycleState(serviceDetails_01, sdncDesignerDetails, LifeCycleStatesEnum.CHECKOUT);
1475                 String newContainerUniqueId = serviceDetails_01.getUniqueId();
1476
1477                 // check if dissoicate of old relation is possibile
1478                 // dissoicateInstancesFail(requirementDefFirstRelation,
1479                 // sdncDesignerDetails, actionStatus, errorCode, variables);
1480                 getComponentAndValidateRIs(serviceDetails_01, 3, 2);
1481
1482                 requirementDefFirstRelation
1483                                 .setFromNode(reqCompInstId.replaceAll(oldContainerUniqueIdToReplace, newContainerUniqueId));
1484                 requirementDefFirstRelation
1485                                 .setToNode(reqCompInstId.replaceAll(oldContainerUniqueIdToReplace, newContainerUniqueId));
1486
1487                 dissociateComponentInstancesForService(requirementDefFirstRelation, serviceDetails_01, sdncDesignerDetails);
1488
1489                 // updateCapabilitiesOwnerId(oldContainerUniqueIdToReplace,
1490                 // capListBeforeAssociate, newContainerUniqueId);
1491                 // CapReqDef capReqDefAfterAssociate =
1492                 // ComponentRestUtils.getAndParseComponentRequirmentsCapabilities(sdncDesignerDetails,
1493                 // serviceDetails_01);
1494                 // List<CapabilityDefinition> capListAfterAssociate =
1495                 // capReqDefAfterAssociate.getCapabilities().get(CAPABILITY_TYPE);
1496                 // List<RequirementDefinition> reqListAfterAssociate =
1497                 // capReqDefAfterAssociate.getRequirements().get(CAPABILITY_TYPE);
1498                 // AssertJUnit.assertEquals("Check requirement", reqListBeforeAssociate,
1499                 // reqListAfterAssociate);
1500                 // AssertJUnit.assertEquals("Check requirement", capListBeforeAssociate,
1501                 // capListAfterAssociate);
1502                 updateExpectedReqCapAfterChangeLifecycleState(oldContainerUniqueIdToReplace, serviceDetails_01.getUniqueId());
1503                 getComponentAndValidateRIs(serviceDetails_01, 3, 1);
1504         }
1505
1506         @Test
1507         public void createResourceInstancesAndUpdatedServiceMetadataTest() throws Exception, Exception {
1508                 serviceDetails_02.setUniqueId(serviceDetails_01.getUniqueId());
1509                 createTwoCheckedinVFInstances();
1510                 LifecycleRestUtils.changeResourceState(resourceDetailsCP_01, sdncDesignerDetails, "0.1",
1511                                 LifeCycleStatesEnum.CHECKIN);
1512                 createVFInstanceAndAtomicResourceInstanceWithoutCheckin(resourceDetailsVF_01, resourceDetailsCP_01,
1513                                 sdncDesignerDetails);
1514                 RestResponse updateServiceResp = ServiceRestUtils.updateService(serviceDetails_02, sdncDesignerDetails);
1515                 ServiceRestUtils.checkSuccess(updateServiceResp);
1516                 getComponentAndValidateRIs(serviceDetails_01, 4, 0);
1517         }
1518
1519         @Test(enabled = false)
1520         public void forAcceptanceUserStory() throws Exception {
1521                 RestResponse createVFInstResp = createVFInstance(serviceDetails_01, resourceDetailsVF_01, sdncDesignerDetails);
1522                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
1523                 String reqCompInstId = ResponseParser.getUniqueIdFromResponse(createVFInstResp);
1524                 createVFInstResp = createVFInstance(serviceDetails_01, resourceDetailsVF_02, sdncDesignerDetails);
1525                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
1526                 String capCompInstId = ResponseParser.getUniqueIdFromResponse(createVFInstResp);
1527
1528                 String capType = CAPABILITY_TYPE;
1529                 String reqName = REQUIREMENT_NAME;
1530
1531                 RestResponse getResourceResponse = ComponentRestUtils.getComponentRequirmentsCapabilities(sdncDesignerDetails,
1532                                 serviceDetails_01);
1533                 ResourceRestUtils.checkSuccess(getResourceResponse);
1534                 CapReqDef capReqDef = ResponseParser.parseToObject(getResourceResponse.getResponse(), CapReqDef.class);
1535                 List<CapabilityDefinition> capList = capReqDef.getCapabilities().get(capType);
1536                 List<RequirementDefinition> reqList = capReqDef.getRequirements().get(capType);
1537
1538                 RequirementCapabilityRelDef requirementDef = getReqCapRelation(reqCompInstId, capCompInstId, capType, reqName,
1539                                 capList, reqList);
1540
1541                 associateComponentInstancesForService(requirementDef, serviceDetails_01, sdncDesignerDetails);
1542                 getResourceResponse = ComponentRestUtils.getComponentRequirmentsCapabilities(sdncDesignerDetails,
1543                                 serviceDetails_01);
1544                 capReqDef = ResponseParser.parseToObject(getResourceResponse.getResponse(), CapReqDef.class);
1545                 List<RequirementDefinition> list = capReqDef.getRequirements().get(capType);
1546                 AssertJUnit.assertEquals("Check requirement", null, list);
1547
1548                 serviceDetails_02.setUniqueId(serviceDetails_01.getUniqueId());
1549                 RestResponse updateServiceResp = ServiceRestUtils.updateService(serviceDetails_02, sdncDesignerDetails);
1550                 ServiceRestUtils.checkSuccess(updateServiceResp);
1551                 changeServiceLifecycleState(serviceDetails_01, sdncDesignerDetails, LifeCycleStatesEnum.CHECKIN);
1552                 getComponentAndValidateRIs(serviceDetails_01, 2, 1);
1553         }
1554
1555         @Test
1556         public void testUnsatisfiedCpReqInService() throws Exception {
1557
1558                 // Certify all the needed atomic resources
1559                 RestResponse response = LifecycleRestUtils.certifyResource(resourceDetailsCP_01);
1560                 ResourceRestUtils.checkSuccess(response);
1561
1562                 ArtifactReqDetails heatArtifactDetails = ElementFactory
1563                                 .getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
1564                 response = ArtifactRestUtils.addInformationalArtifactToResource(heatArtifactDetails, sdncDesignerDetails,
1565                                 resourceDetailsVF_02.getUniqueId());
1566                 ResourceRestUtils.checkSuccess(response);
1567                 response = LifecycleRestUtils.certifyResource(resourceDetailsVF_02);
1568                 ResourceRestUtils.checkSuccess(response);
1569                 capOwnerId = getUniqueIdOfFirstInstanceFromResponse(response);
1570
1571                 RestResponse createAtomicResourceInstance = createVFInstance(serviceDetails_01, resourceDetailsVF_02,
1572                                 sdncDesignerDetails);
1573                 ResourceRestUtils.checkCreateResponse(createAtomicResourceInstance);
1574                 String vfCompInstId = ResponseParser.getUniqueIdFromResponse(createAtomicResourceInstance);
1575
1576                 createAtomicResourceInstance = createAtomicInstanceForService(serviceDetails_01, resourceDetailsCP_01,
1577                                 sdncDesignerDetails);
1578                 ResourceRestUtils.checkCreateResponse(createAtomicResourceInstance);
1579                 String compInstName = ResponseParser.getNameFromResponse(createAtomicResourceInstance);
1580                 String cpCompInstId = ResponseParser.getUniqueIdFromResponse(createAtomicResourceInstance);
1581
1582                 RestResponse submitForTesting = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1583                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1584                 String[] variables = new String[] { serviceDetails_01.getName(), "service", "CP (Connection Point)",
1585                                 compInstName, "requirement", "tosca.capabilities.network.Bindable", "fulfilled" };
1586                 BaseValidationUtils.checkErrorResponse(submitForTesting,
1587                                 ActionStatus.REQ_CAP_NOT_SATISFIED_BEFORE_CERTIFICATION, variables);
1588
1589                 fulfillCpRequirement(serviceDetails_01, cpCompInstId, vfCompInstId, capOwnerId, sdncDesignerDetails,
1590                                 ComponentTypeEnum.SERVICE);
1591
1592                 submitForTesting = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1593                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1594                 BaseValidationUtils.checkSuccess(submitForTesting);
1595         }
1596
1597         @Test
1598         public void getVFInstanceSuccessfullyTest() throws Exception {
1599                 RestResponse createVFInstResp = createCheckedinVFInstance(serviceDetails_01, resourceDetailsVF_01,
1600                                 sdncDesignerDetails);
1601                 ResourceRestUtils.checkCreateResponse(createVFInstResp);
1602                 System.out.println("instance successfuly created");
1603                 RestResponse getInstancesResponce = ComponentInstanceRestUtils.getComponentInstances(ComponentTypeEnum.SERVICE,
1604                                 serviceDetails_01.getUniqueId(), sdncDesignerDetails);
1605
1606                 for (int i = 0; i < 1500; i++) {
1607                         createVFInstResp = createVFInstance(serviceDetails_01, resourceDetailsVF_01, sdncDesignerDetails);
1608                         ResourceRestUtils.checkCreateResponse(createVFInstResp);
1609                         System.out.println("instance " + i + "successfuly created");
1610                 }
1611
1612                 getInstancesResponce = ComponentInstanceRestUtils.getComponentInstances(ComponentTypeEnum.SERVICE,
1613                                 serviceDetails_01.getUniqueId(), sdncDesignerDetails);
1614
1615                 BaseValidationUtils.checkSuccess(getInstancesResponce);
1616
1617         }
1618
1619         private String getUniqueIdOfFirstInstanceFromResponse(RestResponse response) {
1620                 try {
1621                         JSONArray value = ResponseParser.getListFromJson(response, "componentInstances");
1622                         return ResponseParser.getValueFromJsonResponse(value.get(0).toString(), "uniqueId");
1623                 } catch (Exception e) {
1624                         return null;
1625                 }
1626         }
1627 }