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

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