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

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