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