gerrit.onap Code Review - sdc.git/blob

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