gerrit.onap Code Review - sdc.git/blob

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