test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/product/ChangeServiceInstanceVersionTest.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.product;
  22
  23 import org.junit.Rule;
  24 import org.junit.rules.TestName;
  25 import org.openecomp.sdc.be.dao.api.ActionStatus;
  26 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  27 import org.openecomp.sdc.be.model.*;
  28 import org.openecomp.sdc.ci.tests.api.ComponentInstanceBaseTest;
  29 import org.openecomp.sdc.ci.tests.datatypes.ArtifactReqDetails;
  30 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  31 import org.openecomp.sdc.ci.tests.datatypes.enums.ArtifactTypeEnum;
  32 import org.openecomp.sdc.ci.tests.datatypes.enums.LifeCycleStatesEnum;
  33 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  34 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  35 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  36 import org.openecomp.sdc.ci.tests.utils.rest.*;
  37 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  38 import org.testng.annotations.BeforeMethod;
  39 import org.testng.annotations.Test;
  40
  41 import java.util.ArrayList;
  42 import java.util.List;
  43
  44 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.*;
  45 import static org.testng.AssertJUnit.assertEquals;
  46 import static org.testng.AssertJUnit.assertTrue;
  47
  48 public class ChangeServiceInstanceVersionTest extends ComponentInstanceBaseTest {
  49
  50     protected ArtifactReqDetails heatArtifactDetails;
  51     public String firstVfInstanceUniqueId;
  52     public String firstVfInstanceName;
  53     public String secondVfInstanceUniqueId;
  54     public String secoundVfInstanceName;
  55     public String serviceInstanceToReplaceUniqueId;
  56     public String expectedServiceName;
  57     public String expectedPosX;
  58     public String expectedPosY;
  59     public String actualServiceInstanceName;
  60     public String actualPosX;
  61     public String actualPosY;
  62
  63     @Rule
  64     public static TestName name = new TestName();
  65
  66     public ChangeServiceInstanceVersionTest() {
  67         super(name, ChangeServiceInstanceVersionTest.class.getName());
  68     }
  69
  70     @BeforeMethod
  71     public void before() throws Exception {
  72         firstVfInstanceName = null;
  73         secoundVfInstanceName = null;
  74         firstVfInstanceUniqueId = null;
  75         secondVfInstanceUniqueId = null;
  76         serviceInstanceToReplaceUniqueId = null;
  77         expectedServiceName = null;
  78         expectedPosX = null;
  79         expectedPosY = null;
  80         actualServiceInstanceName = null;
  81         actualPosX = null;
  82         actualPosY = null;
  83         init();
  84         createComponents();
  85     }
  86
  87     private void createComponents() throws Exception {
  88         heatArtifactDetails = ElementFactory.getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
  89         createAtomicResource(resourceDetailsVFC_01);
  90         changeResourceStateToCertified(resourceDetailsVFC_01);
  91         createAtomicResource(resourceDetailsCP_01);
  92         changeResourceStateToCertified(resourceDetailsCP_01);
  93         createAtomicResource(resourceDetailsVL_01);
  94         changeResourceStateToCertified(resourceDetailsVL_01);
  95         createAtomicResource(resourceDetailsVFC_02);
  96         changeResourceStateToCertified(resourceDetailsVFC_02);
  97         createAtomicResource(resourceDetailsCP_02);
  98         changeResourceStateToCertified(resourceDetailsCP_02);
  99         createAtomicResource(resourceDetailsVL_02);
 100         changeResourceStateToCertified(resourceDetailsVL_02);
 101         createVF(resourceDetailsVF_02);
 102         createVF(resourceDetailsVF_01);
 103         // create check-In services
 104         createService(serviceDetails_01);
 105         createService(serviceDetails_02);
 106         createService(serviceDetails_03);
 107         createProduct(productDetails_01);
 108         createProduct(productDetails_02);
 109
 110         // add resourceDetailsCP_01 ,resourceDetailsVFC_01 and
 111         // resourceDetailsCP_01 to resourceDetailsVF_01 and certify
 112         // resourceDetailsVF_01
 113         certifyVf(resourceDetailsVF_01, resourceDetailsVFC_02, resourceDetailsCP_01);
 114         // add resourceDetailsCP_02 ,resourceDetailsVFC_02 and
 115         // resourceDetailsVL_02 to resourceDetailsVF_02 and certify
 116         // resourceDetailsVF_02
 117         certifyVf(resourceDetailsVF_02, resourceDetailsVFC_02, resourceDetailsCP_02);
 118         RestResponse createVFInstanceResponse = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF_01,
 119                 sdncDesignerDetails); // serviceDetails_01 has certified
 120         // resourceDetailsVF_01
 121         firstVfInstanceName = ResponseParser.getNameFromResponse(createVFInstanceResponse);
 122         createVFInstanceResponse = createVFInstanceDuringSetup(serviceDetails_02, resourceDetailsVF_02,
 123                 sdncDesignerDetails); // serviceDetails_01 has certified
 124         // resourceDetailsVF_02
 125         secoundVfInstanceName = ResponseParser.getUniqueIdFromResponse(createVFInstanceResponse);
 126         RestResponse restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 127                 LifeCycleStatesEnum.CHECKIN);
 128         ResourceRestUtils.checkSuccess(restResponse);
 129         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_02, sdncDesignerDetails,
 130                 LifeCycleStatesEnum.CHECKIN);
 131         ResourceRestUtils.checkSuccess(restResponse);
 132     }
 133
 134     @Test
 135     public void changeServiceInstanceVersionByPm() throws Exception {
 136         // Adding service instance (serviceDetails_01) to product without saving
 137         // Req&Cap
 138         RestResponse createServiceInstanceResp = createServiceInstanceDuringSetup(productDetails_01, serviceDetails_01,
 139                 sdncPmDetails1);
 140         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 141         String firstServiceInstanceNormalizedName = ResponseParser
 142                 .getValueFromJsonResponse(createServiceInstanceResp.getResponse(), "normalizedName");
 143         // Adding service instance (serviceDetails_02) to product AND ---> Save
 144         // Req&Cap
 145         createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
 146         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 147         // check-in product
 148         RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 149                 LifeCycleStatesEnum.CHECKIN);
 150         ProductRestUtils.checkSuccess(changeStatusResponse);
 151         String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 152         // Checkout service [0.2]
 153         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 154                 LifeCycleStatesEnum.CHECKOUT);
 155         ResourceRestUtils.checkSuccess(changeStatusResponse);
 156         String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 157         serviceDetails_01.setUniqueId(serviceNewUniqueUid);
 158         // get the new VF instance uniqueId after checkout service
 159         RestResponse getServiceResponse = ServiceRestUtils.getService(serviceDetails_01.getUniqueId(), sdncPmDetails1);
 160         Service service = ResponseParser.parseToObjectUsingMapper(getServiceResponse.getResponse(), Service.class);
 161         List<ComponentInstance> serviceComponentInstances = service.getComponentInstances();
 162         for (ComponentInstance component : serviceComponentInstances) {
 163             if (component.getName().equals(firstVfInstanceName)) {
 164                 firstVfInstanceUniqueId = component.getUniqueId();
 165             }
 166         }
 167         assertTrue(firstVfInstanceUniqueId != null);
 168         // delete resource instance (resourceDetailsVF_01) from Service
 169         RestResponse deleteVfFromServiceResponse = deleteVFInstanceDuringSetup(firstVfInstanceUniqueId,
 170                 serviceDetails_01, sdncDesignerDetails);
 171         assertTrue(deleteVfFromServiceResponse.getErrorCode() == STATUS_CODE_SUCCESS_DELETE);
 172         // Add different VF instance (resourceDetailsVF_02) to Service
 173         RestResponse restResponse = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF_02,
 174                 sdncDesignerDetails);
 175         ResourceRestUtils.checkCreateResponse(restResponse);
 176         // Check-In service [0.2]
 177         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 178                 LifeCycleStatesEnum.CHECKIN);
 179         ResourceRestUtils.checkSuccess(changeStatusResponse);
 180         // check-out product
 181         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 182                 LifeCycleStatesEnum.CHECKOUT);
 183         ProductRestUtils.checkSuccess(changeStatusResponse);
 184         String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 185         updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
 186         // get service instance new uniqueId , name and position after checkout
 187         // product
 188         RestResponse getProductResponse = ProductRestUtils.getProduct(productNewUniqueId, sdncPmDetails1.getUserId());
 189         Product product = ResponseParser.parseToObjectUsingMapper(getProductResponse.getResponse(), Product.class);
 190         List<ComponentInstance> componentInstances = product.getComponentInstances();
 191         for (ComponentInstance component : componentInstances) {
 192             if (component.getNormalizedName().equals(firstServiceInstanceNormalizedName)) {
 193                 serviceInstanceToReplaceUniqueId = component.getUniqueId();
 194                 expectedServiceName = component.getName();
 195                 expectedPosX = component.getPosX();
 196                 expectedPosY = component.getPosY();
 197             }
 198         }
 199         assertTrue(serviceInstanceToReplaceUniqueId != null);
 200         // change service instance to newer version
 201         RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
 202                 serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, sdncPmDetails1, ComponentTypeEnum.PRODUCT, true);
 203         ProductRestUtils.checkSuccess(changeServiceInstanceVersionResponse);
 204         actualServiceInstanceName = ResponseParser.getNameFromResponse(changeServiceInstanceVersionResponse);
 205         actualPosX = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
 206                 "posX");
 207         actualPosY = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
 208                 "posY");
 209         ComponentInstance componentInstance = ResponseParser
 210                 .parseToObjectUsingMapper(changeServiceInstanceVersionResponse.getResponse(), ComponentInstance.class);
 211         addCompInstReqCapToExpected(componentInstance, ComponentTypeEnum.PRODUCT);
 212         // Check-in product
 213         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 214                 LifeCycleStatesEnum.CHECKIN);
 215         ProductRestUtils.checkSuccess(changeStatusResponse);
 216         getComponentAndValidateRIs(productDetails_01, 2, 0);
 217         // Verify that Service instance name and position didn't change after
 218         // changing service instance version
 219         assertTrue(actualServiceInstanceName.equals(expectedServiceName));
 220         assertTrue(actualPosX.equals(expectedPosX));
 221         assertTrue(actualPosY.equals(expectedPosY));
 222     }
 223
 224     @Test
 225     public void changeServiceInstanceVersionByAdmin() throws Exception {
 226         // Adding service instance (serviceDetails_01) to product without saving
 227         // Req&Cap
 228         RestResponse createServiceInstanceResp = createServiceInstanceDuringSetup(productDetails_01, serviceDetails_01,
 229                 sdncPmDetails1);
 230         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 231         String firstServiceInstanceNormalizedName = ResponseParser
 232                 .getValueFromJsonResponse(createServiceInstanceResp.getResponse(), "normalizedName");
 233         // Adding service instance (serviceDetails_02) to product AND ---> Save
 234         // Req&Cap
 235         createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
 236         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 237         // check-in product
 238         RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 239                 LifeCycleStatesEnum.CHECKIN);
 240         ProductRestUtils.checkSuccess(changeStatusResponse);
 241         String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 242         // Checkout service [0.2]
 243         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 244                 LifeCycleStatesEnum.CHECKOUT);
 245         ResourceRestUtils.checkSuccess(changeStatusResponse);
 246         String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 247         serviceDetails_01.setUniqueId(serviceNewUniqueUid);
 248         // get the new VF instance uniqueId after checkout service
 249         RestResponse getServiceResponse = ServiceRestUtils.getService(serviceDetails_01.getUniqueId(), sdncPmDetails1);
 250         Service service = ResponseParser.parseToObjectUsingMapper(getServiceResponse.getResponse(), Service.class);
 251         List<ComponentInstance> serviceComponentInstances = service.getComponentInstances();
 252         for (ComponentInstance component : serviceComponentInstances) {
 253             if (component.getName().equals(firstVfInstanceName)) {
 254                 firstVfInstanceUniqueId = component.getUniqueId();
 255             }
 256         }
 257         assertTrue(firstVfInstanceUniqueId != null);
 258         // delete resource instance (resourceDetailsVF_01) from Service
 259         RestResponse deleteVfFromServiceResponse = deleteVFInstanceDuringSetup(firstVfInstanceUniqueId,
 260                 serviceDetails_01, sdncDesignerDetails);
 261         assertTrue(deleteVfFromServiceResponse.getErrorCode() == STATUS_CODE_SUCCESS_DELETE);
 262         // Add different VF instance (resourceDetailsVF_02) to Service
 263         RestResponse restResponse = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF_02,
 264                 sdncDesignerDetails);
 265         ResourceRestUtils.checkCreateResponse(restResponse);
 266         // service [0.2] state to CERTIFICATIONREQUEST
 267         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 268                 LifeCycleStatesEnum.CHECKIN);
 269         ResourceRestUtils.checkSuccess(changeStatusResponse);
 270         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 271                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 272         ResourceRestUtils.checkSuccess(changeStatusResponse);
 273         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncTesterDetails,
 274                 LifeCycleStatesEnum.STARTCERTIFICATION);
 275         ResourceRestUtils.checkSuccess(changeStatusResponse);
 276         // check-out product
 277         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncAdminDetails,
 278                 LifeCycleStatesEnum.CHECKOUT);
 279         ProductRestUtils.checkSuccess(changeStatusResponse);
 280         String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 281         updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
 282         // get service instance new uniqueId , name and position after checkout
 283         // product
 284         RestResponse getProductResponse = ProductRestUtils.getProduct(productNewUniqueId, sdncPmDetails1.getUserId());
 285         Product product = ResponseParser.parseToObjectUsingMapper(getProductResponse.getResponse(), Product.class);
 286         List<ComponentInstance> componentInstances = product.getComponentInstances();
 287         for (ComponentInstance component : componentInstances) {
 288             if (component.getNormalizedName().equals(firstServiceInstanceNormalizedName)) {
 289                 serviceInstanceToReplaceUniqueId = component.getUniqueId();
 290                 expectedServiceName = component.getName();
 291                 expectedPosX = component.getPosX();
 292                 expectedPosY = component.getPosY();
 293             }
 294         }
 295         assertTrue(serviceInstanceToReplaceUniqueId != null);
 296         // change service instance to newer version
 297         RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
 298                 serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, sdncAdminDetails, ComponentTypeEnum.PRODUCT,
 299                 true);
 300         ProductRestUtils.checkSuccess(changeServiceInstanceVersionResponse);
 301         actualServiceInstanceName = ResponseParser.getNameFromResponse(changeServiceInstanceVersionResponse);
 302         actualPosX = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
 303                 "posX");
 304         actualPosY = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
 305                 "posY");
 306         ComponentInstance componentInstance = ResponseParser
 307                 .parseToObjectUsingMapper(changeServiceInstanceVersionResponse.getResponse(), ComponentInstance.class);
 308         addCompInstReqCapToExpected(componentInstance, ComponentTypeEnum.PRODUCT);
 309         // Check-in product
 310         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncAdminDetails,
 311                 LifeCycleStatesEnum.CHECKIN);
 312         ProductRestUtils.checkSuccess(changeStatusResponse);
 313         getComponentAndValidateRIs(productDetails_01, 2, 0);
 314         // Verify that Service instance name and position didn't change after
 315         // changing service instance version
 316         assertTrue(actualServiceInstanceName.equals(expectedServiceName));
 317         assertTrue(actualPosX.equals(expectedPosX));
 318         assertTrue(actualPosY.equals(expectedPosY));
 319     }
 320
 321     @Test
 322     public void changeServiceInstanceToOlderVersion() throws Exception {
 323         // Get VF Instance UniquId [Service version 0.1]
 324         RestResponse getServiceResponse = ServiceRestUtils.getService(serviceDetails_01.getUniqueId(), sdncPmDetails1);
 325         Service service = ResponseParser.parseToObjectUsingMapper(getServiceResponse.getResponse(), Service.class);
 326         ComponentInstance actualComponentInstance = service.getComponentInstances().get(0);
 327         firstVfInstanceUniqueId = actualComponentInstance.getUniqueId();
 328         String serviceOlderVersionUniquId = ResponseParser.getUniqueIdFromResponse(getServiceResponse);
 329
 330         // Checkout service [0.2]
 331         RestResponse changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01,
 332                 sdncDesignerDetails, LifeCycleStatesEnum.CHECKOUT);
 333         ResourceRestUtils.checkSuccess(changeStatusResponse);
 334         String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 335         serviceDetails_01.setUniqueId(serviceNewUniqueUid);
 336         // get the new VF instance uniqueId after checkout service
 337         getServiceResponse = ServiceRestUtils.getService(serviceDetails_01.getUniqueId(), sdncPmDetails1);
 338         service = ResponseParser.parseToObjectUsingMapper(getServiceResponse.getResponse(), Service.class);
 339         List<ComponentInstance> serviceComponentInstances = service.getComponentInstances();
 340         for (ComponentInstance component : serviceComponentInstances) {
 341             if (component.getName().equals(firstVfInstanceName)) {
 342                 firstVfInstanceUniqueId = component.getUniqueId();
 343             }
 344         }
 345         assertTrue(firstVfInstanceUniqueId != null);
 346         // delete resource instance (resourceDetailsVF_01) from Service
 347         RestResponse deleteVfFromServiceResponse = deleteVFInstanceDuringSetup(firstVfInstanceUniqueId,
 348                 serviceDetails_01, sdncDesignerDetails);
 349         assertTrue(deleteVfFromServiceResponse.getErrorCode() == STATUS_CODE_SUCCESS_DELETE);
 350         // Add different VF instance (resourceDetailsVF_02) to Service
 351         RestResponse restResponse = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF_02,
 352                 sdncDesignerDetails);
 353         ResourceRestUtils.checkCreateResponse(restResponse);
 354         // Check-In service [0.2]
 355         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 356                 LifeCycleStatesEnum.CHECKIN);
 357         ResourceRestUtils.checkSuccess(changeStatusResponse);
 358         // Adding service instance (serviceDetails_01 V0.2) to product without
 359         // saving Req&Cap
 360         RestResponse createServiceInstanceResp = createServiceInstanceDuringSetup(productDetails_01, serviceDetails_01,
 361                 sdncPmDetails1);
 362         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 363         String firstServiceInstanceNormalizedName = ResponseParser
 364                 .getValueFromJsonResponse(createServiceInstanceResp.getResponse(), "normalizedName");
 365         // Adding service instance (serviceDetails_02) to product AND ---> Save
 366         // Req&Cap
 367         createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
 368         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 369         // check-in product
 370         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 371                 LifeCycleStatesEnum.CHECKIN);
 372         ProductRestUtils.checkSuccess(changeStatusResponse);
 373         String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 374         // check-out product
 375         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 376                 LifeCycleStatesEnum.CHECKOUT);
 377         ProductRestUtils.checkSuccess(changeStatusResponse);
 378         String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 379         updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
 380         // get service instance new uniqueId , name and position after checkout
 381         // product
 382         RestResponse getProductResponse = ProductRestUtils.getProduct(productNewUniqueId, sdncPmDetails1.getUserId());
 383         Product product = ResponseParser.parseToObjectUsingMapper(getProductResponse.getResponse(), Product.class);
 384         List<ComponentInstance> componentInstances = product.getComponentInstances();
 385         for (ComponentInstance component : componentInstances) {
 386             if (component.getNormalizedName().equals(firstServiceInstanceNormalizedName)) {
 387                 serviceInstanceToReplaceUniqueId = component.getUniqueId();
 388                 expectedServiceName = component.getName();
 389                 expectedPosX = component.getPosX();
 390                 expectedPosY = component.getPosY();
 391             }
 392         }
 393         assertTrue(serviceInstanceToReplaceUniqueId != null);
 394         // change service instance to Older version
 395         RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
 396                 serviceInstanceToReplaceUniqueId, serviceOlderVersionUniquId, sdncPmDetails1, ComponentTypeEnum.PRODUCT,
 397                 true);
 398         // RestResponse changeServiceInstanceVersionResponse =
 399         // changeServiceInstanceVersion(productDetails_01.getUniqueId(),
 400         // serviceInstanceToReplaceUniqueId , serviceNewUniqueUid,
 401         // sdncPmDetails1, ComponentTypeEnum.PRODUCT , true);
 402         ProductRestUtils.checkSuccess(changeServiceInstanceVersionResponse);
 403         actualServiceInstanceName = ResponseParser.getNameFromResponse(changeServiceInstanceVersionResponse);
 404         actualPosX = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
 405                 "posX");
 406         actualPosY = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
 407                 "posY");
 408         ComponentInstance componentInstance = ResponseParser
 409                 .parseToObjectUsingMapper(changeServiceInstanceVersionResponse.getResponse(), ComponentInstance.class);
 410         addCompInstReqCapToExpected(componentInstance, ComponentTypeEnum.PRODUCT);
 411         // Check-in product
 412         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 413                 LifeCycleStatesEnum.CHECKIN);
 414         ProductRestUtils.checkSuccess(changeStatusResponse);
 415         getComponentAndValidateRIs(productDetails_01, 2, 0);
 416         // Verify that Service instance name and position didn't change after
 417         // changing service instance version
 418         assertTrue(actualServiceInstanceName.equals(expectedServiceName));
 419         assertTrue(actualPosX.equals(expectedPosX));
 420         assertTrue(actualPosY.equals(expectedPosY));
 421     }
 422
 423     // DE190201
 424     @Test
 425     public void changeServiceInstanceVersionToCertifiedVersion() throws Exception {
 426         // Adding service instance (serviceDetails_01) to product without saving
 427         // Req&Cap
 428         RestResponse createServiceInstanceResp = createServiceInstanceDuringSetup(productDetails_01, serviceDetails_01,
 429                 sdncPmDetails1);
 430         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 431         String firstServiceInstanceNormalizedName = ResponseParser
 432                 .getValueFromJsonResponse(createServiceInstanceResp.getResponse(), "normalizedName");
 433         // Adding service instance (serviceDetails_02) to product AND ---> Save
 434         // Req&Cap
 435         createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
 436         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 437         // check-in product
 438         RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 439                 LifeCycleStatesEnum.CHECKIN);
 440         ProductRestUtils.checkSuccess(changeStatusResponse);
 441         String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 442         // Checkout service [0.2]
 443         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 444                 LifeCycleStatesEnum.CHECKOUT);
 445         ResourceRestUtils.checkSuccess(changeStatusResponse);
 446         /*
 447                  * String serviceNewUniqueUid =
 448                  * ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 449                  * serviceDetails_01.setUniqueId(serviceNewUniqueUid);
 450                  */
 451         // get the new VF instance uniqueId after checkout service
 452         RestResponse getServiceResponse = ServiceRestUtils.getService(serviceDetails_01.getUniqueId(), sdncPmDetails1);
 453         Service service = ResponseParser.parseToObjectUsingMapper(getServiceResponse.getResponse(), Service.class);
 454         List<ComponentInstance> serviceComponentInstances = service.getComponentInstances();
 455         for (ComponentInstance component : serviceComponentInstances) {
 456             if (component.getName().equals(firstVfInstanceName)) {
 457                 firstVfInstanceUniqueId = component.getUniqueId();
 458             }
 459         }
 460         assertTrue(firstVfInstanceUniqueId != null);
 461         // delete resource instance (resourceDetailsVF_01) from Service
 462         RestResponse deleteVfFromServiceResponse = deleteVFInstanceDuringSetup(firstVfInstanceUniqueId,
 463                 serviceDetails_01, sdncDesignerDetails);
 464         assertTrue(deleteVfFromServiceResponse.getErrorCode() == STATUS_CODE_SUCCESS_DELETE);
 465         // Add different VF instance (resourceDetailsVF_02) to Service
 466         RestResponse restResponse = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF_02,
 467                 sdncDesignerDetails);
 468         ResourceRestUtils.checkCreateResponse(restResponse);
 469         // Check-In service [0.2]
 470         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 471                 LifeCycleStatesEnum.CHECKIN);
 472         ResourceRestUtils.checkSuccess(changeStatusResponse);
 473         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 474                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 475         ResourceRestUtils.checkSuccess(changeStatusResponse);
 476         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncTesterDetails,
 477                 LifeCycleStatesEnum.STARTCERTIFICATION);
 478         ResourceRestUtils.checkSuccess(changeStatusResponse);
 479         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncTesterDetails,
 480                 LifeCycleStatesEnum.CERTIFY);
 481         ResourceRestUtils.checkSuccess(changeStatusResponse);
 482         String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 483         // check-out product
 484         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 485                 LifeCycleStatesEnum.CHECKOUT);
 486         ProductRestUtils.checkSuccess(changeStatusResponse);
 487         String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 488         updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
 489         // get service instance new uniqueId , name and position after checkout
 490         // product
 491         RestResponse getProductResponse = ProductRestUtils.getProduct(productNewUniqueId, sdncPmDetails1.getUserId());
 492         Product product = ResponseParser.parseToObjectUsingMapper(getProductResponse.getResponse(), Product.class);
 493         List<ComponentInstance> componentInstances = product.getComponentInstances();
 494         for (ComponentInstance component : componentInstances) {
 495             if (component.getNormalizedName().equals(firstServiceInstanceNormalizedName)) {
 496                 serviceInstanceToReplaceUniqueId = component.getUniqueId();
 497                 expectedServiceName = component.getName();
 498                 expectedPosX = component.getPosX();
 499                 expectedPosY = component.getPosY();
 500             }
 501         }
 502         assertTrue(serviceInstanceToReplaceUniqueId != null);
 503         // change service instance to newer version
 504         RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
 505                 serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, sdncPmDetails1, ComponentTypeEnum.PRODUCT, true);
 506         // RestResponse changeServiceInstanceVersionResponse =
 507         // changeServiceInstanceVersion(productDetails_01.getUniqueId(),
 508         // serviceInstanceToReplaceUniqueId , serviceNewUniqueUid,
 509         // sdncPmDetails1, ComponentTypeEnum.PRODUCT , true);
 510         ProductRestUtils.checkSuccess(changeServiceInstanceVersionResponse);
 511         actualServiceInstanceName = ResponseParser.getNameFromResponse(changeServiceInstanceVersionResponse);
 512         actualPosX = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
 513                 "posX");
 514         actualPosY = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
 515                 "posY");
 516         ComponentInstance componentInstance = ResponseParser
 517                 .parseToObjectUsingMapper(changeServiceInstanceVersionResponse.getResponse(), ComponentInstance.class);
 518         addCompInstReqCapToExpected(componentInstance, ComponentTypeEnum.PRODUCT);
 519         // Check-in product
 520         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 521                 LifeCycleStatesEnum.CHECKIN);
 522         ProductRestUtils.checkSuccess(changeStatusResponse);
 523         getComponentAndValidateRIs(productDetails_01, 2, 0);
 524         // Verify that Service instance name and position didn't change after
 525         // changing service instance version
 526         assertTrue(actualServiceInstanceName.equals(expectedServiceName));
 527         assertTrue(actualPosX.equals(expectedPosX));
 528         assertTrue(actualPosY.equals(expectedPosY));
 529     }
 530
 531     // DE191927
 532     @Test(enabled = false)
 533     public void changeServiceInstanceVersionThenReCheckInProduct() throws Exception {
 534         // Adding service instance (serviceDetails_01) to product without saving
 535         // Req&Cap
 536         RestResponse createServiceInstanceResp = createServiceInstanceDuringSetup(productDetails_01, serviceDetails_01,
 537                 sdncPmDetails1);
 538         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 539         String firstServiceInstanceNormalizedName = ResponseParser
 540                 .getValueFromJsonResponse(createServiceInstanceResp.getResponse(), "normalizedName");
 541         // Adding service instance (serviceDetails_02) to product AND ---> Save
 542         // Req&Cap
 543         createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
 544         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 545         // check-in product
 546         RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 547                 LifeCycleStatesEnum.CHECKIN);
 548         ProductRestUtils.checkSuccess(changeStatusResponse);
 549         String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 550         // Checkout service [0.2]
 551         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 552                 LifeCycleStatesEnum.CHECKOUT);
 553         ResourceRestUtils.checkSuccess(changeStatusResponse);
 554         String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 555         serviceDetails_01.setUniqueId(serviceNewUniqueUid);
 556         // get the new VF instance uniqueId after checkout service
 557         RestResponse getServiceResponse = ServiceRestUtils.getService(serviceDetails_01.getUniqueId(), sdncPmDetails1);
 558         Service service = ResponseParser.parseToObjectUsingMapper(getServiceResponse.getResponse(), Service.class);
 559         List<ComponentInstance> serviceComponentInstances = service.getComponentInstances();
 560         for (ComponentInstance component : serviceComponentInstances) {
 561             if (component.getName().equals(firstVfInstanceName)) {
 562                 firstVfInstanceUniqueId = component.getUniqueId();
 563             }
 564         }
 565         assertTrue(firstVfInstanceUniqueId != null);
 566         // delete resource instance (resourceDetailsVF_01) from Service
 567         RestResponse deleteVfFromServiceResponse = deleteVFInstanceDuringSetup(firstVfInstanceUniqueId,
 568                 serviceDetails_01, sdncDesignerDetails);
 569         assertTrue(deleteVfFromServiceResponse.getErrorCode() == STATUS_CODE_SUCCESS_DELETE);
 570         // Add different VF instance (resourceDetailsVF_02) to Service
 571         RestResponse restResponse = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF_02,
 572                 sdncDesignerDetails);
 573         ResourceRestUtils.checkCreateResponse(restResponse);
 574         // Check-In service [0.2]
 575         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 576                 LifeCycleStatesEnum.CHECKIN);
 577         ResourceRestUtils.checkSuccess(changeStatusResponse);
 578         // check-out product
 579         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 580                 LifeCycleStatesEnum.CHECKOUT);
 581         ProductRestUtils.checkSuccess(changeStatusResponse);
 582         String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 583         updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
 584         // get service instance new uniqueId , name and position after checkout
 585         // product
 586         RestResponse getProductResponse = ProductRestUtils.getProduct(productNewUniqueId, sdncPmDetails1.getUserId());
 587         Product product = ResponseParser.parseToObjectUsingMapper(getProductResponse.getResponse(), Product.class);
 588         List<ComponentInstance> componentInstances = product.getComponentInstances();
 589         for (ComponentInstance component : componentInstances) {
 590             if (component.getNormalizedName().equals(firstServiceInstanceNormalizedName)) {
 591                 serviceInstanceToReplaceUniqueId = component.getUniqueId();
 592                 expectedServiceName = component.getName();
 593                 expectedPosX = component.getPosX();
 594                 expectedPosY = component.getPosY();
 595             }
 596         }
 597         assertTrue(serviceInstanceToReplaceUniqueId != null);
 598         // change service instance to newer version
 599         RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
 600                 serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, sdncPmDetails1, ComponentTypeEnum.PRODUCT, true);
 601         ProductRestUtils.checkSuccess(changeServiceInstanceVersionResponse);
 602         actualServiceInstanceName = ResponseParser.getNameFromResponse(changeServiceInstanceVersionResponse);
 603         actualPosX = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
 604                 "posX");
 605         actualPosY = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
 606                 "posY");
 607         ComponentInstance componentInstance = ResponseParser
 608                 .parseToObjectUsingMapper(changeServiceInstanceVersionResponse.getResponse(), ComponentInstance.class);
 609         addCompInstReqCapToExpected(componentInstance, ComponentTypeEnum.PRODUCT);
 610         // Check-in product
 611         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 612                 LifeCycleStatesEnum.CHECKIN);
 613         ProductRestUtils.checkSuccess(changeStatusResponse);
 614         /////////////////////
 615         productOldUniqueId = productDetails_01.getUniqueId();
 616         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 617                 LifeCycleStatesEnum.CHECKOUT);
 618         ProductRestUtils.checkSuccess(changeStatusResponse);
 619         // Check-in product
 620         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 621                 LifeCycleStatesEnum.CHECKIN);
 622         ProductRestUtils.checkSuccess(changeStatusResponse);
 623         productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 624         updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
 625         /////////////////////////////////////////////
 626         getComponentAndValidateRIs(productDetails_01, 2, 0);
 627         // Verify that Service instance name and position didn't change after
 628         // changing service instance version
 629         assertTrue(actualServiceInstanceName.equals(expectedServiceName));
 630         assertTrue(actualPosX.equals(expectedPosX));
 631         assertTrue(actualPosY.equals(expectedPosY));
 632     }
 633
 634     @Test
 635     public void changeServiceInstanceToHisVersion() throws Exception {
 636         // Get VF Instance UniquId [Service version 0.1]
 637         RestResponse getServiceResponse = ServiceRestUtils.getService(serviceDetails_01.getUniqueId(), sdncPmDetails1);
 638         String serviceOlderVersionUniquId = ResponseParser.getUniqueIdFromResponse(getServiceResponse);
 639         // Adding service instance (serviceDetails_01) to product without saving
 640         // Req&Cap
 641         RestResponse createServiceInstanceResp = createServiceInstanceDuringSetup(productDetails_01, serviceDetails_01,
 642                 sdncPmDetails1);
 643         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 644         String firstServiceInstanceNormalizedName = ResponseParser
 645                 .getValueFromJsonResponse(createServiceInstanceResp.getResponse(), "normalizedName");
 646         // Adding service instance (serviceDetails_02) to product AND ---> Save
 647         // Req&Cap
 648         createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
 649         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 650         // check-in product
 651         RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 652                 LifeCycleStatesEnum.CHECKIN);
 653         ProductRestUtils.checkSuccess(changeStatusResponse);
 654         String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 655         // Checkout service [0.2]
 656         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 657                 LifeCycleStatesEnum.CHECKOUT);
 658         ResourceRestUtils.checkSuccess(changeStatusResponse);
 659         String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 660         serviceDetails_01.setUniqueId(serviceNewUniqueUid);
 661         // get the new VF instance uniqueId after checkout service
 662         getServiceResponse = ServiceRestUtils.getService(serviceDetails_01.getUniqueId(), sdncPmDetails1);
 663         Service service = ResponseParser.parseToObjectUsingMapper(getServiceResponse.getResponse(), Service.class);
 664         List<ComponentInstance> serviceComponentInstances = service.getComponentInstances();
 665         for (ComponentInstance component : serviceComponentInstances) {
 666             if (component.getName().equals(firstVfInstanceName)) {
 667                 firstVfInstanceUniqueId = component.getUniqueId();
 668             }
 669         }
 670         assertTrue(firstVfInstanceUniqueId != null);
 671         // delete resource instance (resourceDetailsVF_01) from Service
 672         RestResponse deleteVfFromServiceResponse = deleteVFInstanceDuringSetup(firstVfInstanceUniqueId,
 673                 serviceDetails_01, sdncDesignerDetails);
 674         assertTrue(deleteVfFromServiceResponse.getErrorCode() == STATUS_CODE_SUCCESS_DELETE);
 675         // Add different VF instance (resourceDetailsVF_02) to Service
 676         RestResponse restResponse = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF_02,
 677                 sdncDesignerDetails);
 678         ResourceRestUtils.checkCreateResponse(restResponse);
 679         // Check-In service [0.2]
 680         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 681                 LifeCycleStatesEnum.CHECKIN);
 682         ResourceRestUtils.checkSuccess(changeStatusResponse);
 683         // check-out product
 684         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 685                 LifeCycleStatesEnum.CHECKOUT);
 686         ProductRestUtils.checkSuccess(changeStatusResponse);
 687         String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 688         updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
 689         // get service instance new uniqueId , name and position after checkout
 690         // product
 691         RestResponse getProductResponse = ProductRestUtils.getProduct(productNewUniqueId, sdncPmDetails1.getUserId());
 692         Product product = ResponseParser.parseToObjectUsingMapper(getProductResponse.getResponse(), Product.class);
 693         List<ComponentInstance> componentInstances = product.getComponentInstances();
 694         for (ComponentInstance component : componentInstances) {
 695             if (component.getNormalizedName().equals(firstServiceInstanceNormalizedName)) {
 696                 serviceInstanceToReplaceUniqueId = component.getUniqueId();
 697                 expectedServiceName = component.getName();
 698                 expectedPosX = component.getPosX();
 699                 expectedPosY = component.getPosY();
 700             }
 701         }
 702         assertTrue(serviceInstanceToReplaceUniqueId != null);
 703         // change service instance to newer version
 704         RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
 705                 serviceInstanceToReplaceUniqueId, serviceOlderVersionUniquId, sdncPmDetails1, ComponentTypeEnum.PRODUCT,
 706                 true);
 707         // RestResponse changeServiceInstanceVersionResponse =
 708         // changeServiceInstanceVersion(productDetails_01.getUniqueId(),
 709         // serviceInstanceToReplaceUniqueId , serviceNewUniqueUid,
 710         // sdncPmDetails1, ComponentTypeEnum.PRODUCT , true);
 711         ProductRestUtils.checkSuccess(changeServiceInstanceVersionResponse);
 712         actualServiceInstanceName = ResponseParser.getNameFromResponse(changeServiceInstanceVersionResponse);
 713         actualPosX = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
 714                 "posX");
 715         actualPosY = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
 716                 "posY");
 717         ComponentInstance componentInstance = ResponseParser
 718                 .parseToObjectUsingMapper(changeServiceInstanceVersionResponse.getResponse(), ComponentInstance.class);
 719         addCompInstReqCapToExpected(componentInstance, ComponentTypeEnum.PRODUCT);
 720         // Check-in product
 721         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 722                 LifeCycleStatesEnum.CHECKIN);
 723         ProductRestUtils.checkSuccess(changeStatusResponse);
 724         getComponentAndValidateRIs(productDetails_01, 2, 0);
 725         // Verify that Service instance name and position didn't change after
 726         // changing service instance version
 727         assertTrue(actualServiceInstanceName.equals(expectedServiceName));
 728         assertTrue(actualPosX.equals(expectedPosX));
 729         assertTrue(actualPosY.equals(expectedPosY));
 730     }
 731
 732     @Test
 733     public void changeServiceInstanceVersionByAdminNotByProductOwner() throws Exception {
 734         // Adding service instance (serviceDetails_01) to product without saving
 735         // Req&Cap
 736         RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01,
 737                 sdncPmDetails1);
 738         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 739         // Adding service instance (serviceDetails_02) to product AND ---> Save
 740         // Req&Cap
 741         createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
 742         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 743         // check-in product
 744         RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 745                 LifeCycleStatesEnum.CHECKIN);
 746         ProductRestUtils.checkSuccess(changeStatusResponse);
 747         String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 748         // Checkout service [0.2]
 749         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 750                 LifeCycleStatesEnum.CHECKOUT);
 751         ResourceRestUtils.checkSuccess(changeStatusResponse);
 752         String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 753         // Check-In service [0.2]
 754         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 755                 LifeCycleStatesEnum.CHECKIN);
 756         ResourceRestUtils.checkSuccess(changeStatusResponse);
 757         // check-out product
 758         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 759                 LifeCycleStatesEnum.CHECKOUT);
 760         ProductRestUtils.checkSuccess(changeStatusResponse);
 761         String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 762         updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
 763
 764         // change service instance to newer version
 765         RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
 766                 serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, sdncAdminDetails, ComponentTypeEnum.PRODUCT,
 767                 true);
 768         assertEquals("Check response code ", STATUS_CODE_RESTRICTED_OPERATION,
 769                 changeServiceInstanceVersionResponse.getErrorCode().intValue());
 770         ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
 771                 changeServiceInstanceVersionResponse.getResponse());
 772         // Check-in product
 773         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 774                 LifeCycleStatesEnum.CHECKIN);
 775         ProductRestUtils.checkSuccess(changeStatusResponse);
 776         getComponentAndValidateRIs(productDetails_01, 2, 0);
 777
 778     }
 779
 780     @Test
 781     public void changeServiceInstanceVersionByPmNotByProductOwner() throws Exception {
 782         // Adding service instance (serviceDetails_01) to product AND --->
 783         // saving Req&Cap
 784         RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01,
 785                 sdncPmDetails1);
 786         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 787         // Adding service instance (serviceDetails_02) to product AND ---> Save
 788         // Req&Cap
 789         createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
 790         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 791         // check-in product
 792         RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 793                 LifeCycleStatesEnum.CHECKIN);
 794         ProductRestUtils.checkSuccess(changeStatusResponse);
 795         String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 796         // Checkout service [0.2]
 797         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 798                 LifeCycleStatesEnum.CHECKOUT);
 799         ResourceRestUtils.checkSuccess(changeStatusResponse);
 800         String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 801         serviceDetails_01.setUniqueId(serviceNewUniqueUid);
 802         // Check-In service [0.2]
 803         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 804                 LifeCycleStatesEnum.CHECKIN);
 805         ResourceRestUtils.checkSuccess(changeStatusResponse);
 806         // check-out product
 807         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 808                 LifeCycleStatesEnum.CHECKOUT);
 809         ProductRestUtils.checkSuccess(changeStatusResponse);
 810         String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 811         // change uniqueId after product check-out in expected Req&Cap
 812         updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
 813         updateNewComponentInstanceId(createServiceInstanceResp, productNewUniqueId);
 814         // CHANGE Service Instance VERSION BY NON PRODUCT OWNER (sdncPmDetails1
 815         // instead sdncPmDetails1)
 816         RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(
 817                 productDetails_01.getUniqueId(), serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, sdncPmDetails2,
 818                 ComponentTypeEnum.PRODUCT, true);
 819         assertEquals("Check response code ", STATUS_CODE_RESTRICTED_OPERATION,
 820                 changeServiceInstanceVersionResponse.getErrorCode().intValue());
 821         ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
 822                 changeServiceInstanceVersionResponse.getResponse());
 823         // Check-in product
 824         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 825                 LifeCycleStatesEnum.CHECKIN);
 826         ProductRestUtils.checkSuccess(changeStatusResponse);
 827         getComponentAndValidateRIs(productDetails_01, 2, 0);
 828     }
 829
 830     @Test
 831     public void changeServiceInstanceVersionByTester() throws Exception {
 832         // Adding service instance (serviceDetails_01) to product AND --->
 833         // saving Req&Cap
 834         RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01,
 835                 sdncPmDetails1);
 836         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 837         String serviceInstanceToReplaceUniqueId = ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
 838         // Adding service instance (serviceDetails_02) to product AND ---> Save
 839         // Req&Cap
 840         createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
 841         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 842         // check-in product
 843         RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 844                 LifeCycleStatesEnum.CHECKIN);
 845         ProductRestUtils.checkSuccess(changeStatusResponse);
 846         String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 847         // Checkout service [0.2]
 848         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 849                 LifeCycleStatesEnum.CHECKOUT);
 850         ResourceRestUtils.checkSuccess(changeStatusResponse);
 851         String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 852         serviceDetails_01.setUniqueId(serviceNewUniqueUid);
 853         // Check-In service [0.2]
 854         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 855                 LifeCycleStatesEnum.CHECKIN);
 856         ResourceRestUtils.checkSuccess(changeStatusResponse);
 857         // check-out product
 858         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 859                 LifeCycleStatesEnum.CHECKOUT);
 860         ProductRestUtils.checkSuccess(changeStatusResponse);
 861         String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 862         // change uniqueId after product check-out in expected Req&Cap
 863         updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
 864         // CHANGE Service Instance VERSION BY NON PRODUCT OWNER (sdncPmDetails1
 865         // instead sdncPmDetails1)
 866         RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(
 867                 productDetails_01.getUniqueId(), serviceInstanceToReplaceUniqueId, serviceNewUniqueUid,
 868                 sdncTesterDetails, ComponentTypeEnum.PRODUCT, true);
 869         assertEquals("Check response code ", STATUS_CODE_RESTRICTED_OPERATION,
 870                 changeServiceInstanceVersionResponse.getErrorCode().intValue());
 871         ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
 872                 changeServiceInstanceVersionResponse.getResponse());
 873         // Check-in product
 874         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 875                 LifeCycleStatesEnum.CHECKIN);
 876         ProductRestUtils.checkSuccess(changeStatusResponse);
 877         getComponentAndValidateRIs(productDetails_01, 2, 0);
 878     }
 879
 880     @Test
 881     public void changeServiceInstanceVersionProductIsNotCheckOut() throws Exception {
 882         // Adding service instance (serviceDetails_01) to product AND --->
 883         // saving Req&Cap
 884         RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01,
 885                 sdncPmDetails1);
 886         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 887         String serviceInstanceToReplaceUniqueId = ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
 888         // Adding service instance (serviceDetails_02) to product AND ---> Save
 889         // Req&Cap
 890         createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
 891         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 892         // check-in product
 893         RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 894                 LifeCycleStatesEnum.CHECKIN);
 895         ProductRestUtils.checkSuccess(changeStatusResponse);
 896         String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 897         // Checkout service [0.2]
 898         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 899                 LifeCycleStatesEnum.CHECKOUT);
 900         ResourceRestUtils.checkSuccess(changeStatusResponse);
 901         String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 902         serviceDetails_01.setUniqueId(serviceNewUniqueUid);
 903         // Check-In service [0.2]
 904         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 905                 LifeCycleStatesEnum.CHECKIN);
 906         ResourceRestUtils.checkSuccess(changeStatusResponse);
 907         // CHANGE Service Instance VERSION for Non checkedOut product
 908         RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productOldUniqueId,
 909                 serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, sdncPmDetails1, ComponentTypeEnum.PRODUCT, true);
 910         assertEquals("Check response code ", STATUS_CODE_RESTRICTED_OPERATION,
 911                 changeServiceInstanceVersionResponse.getErrorCode().intValue());
 912         ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
 913                 changeServiceInstanceVersionResponse.getResponse());
 914         getComponentAndValidateRIs(productDetails_01, 2, 0);
 915     }
 916
 917     // DE191727
 918     @Test(enabled = false)
 919     public void changeServiceInstanceVersionServiceIsInCheckOutState() throws Exception {
 920         // Adding service instance (serviceDetails_01) to product AND --->
 921         // saving Req&Cap
 922         RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01,
 923                 sdncPmDetails1);
 924         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 925         String serviceInstanceToReplaceUniqueId = ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
 926         // Adding service instance (serviceDetails_02) to product AND ---> Save
 927         // Req&Cap
 928         createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
 929         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 930         // check-in product
 931         RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 932                 LifeCycleStatesEnum.CHECKIN);
 933         ProductRestUtils.checkSuccess(changeStatusResponse);
 934         String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 935         // Checkout service [0.2]
 936         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 937                 LifeCycleStatesEnum.CHECKOUT);
 938         ResourceRestUtils.checkSuccess(changeStatusResponse);
 939         String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 940         // check-out product
 941         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 942                 LifeCycleStatesEnum.CHECKOUT);
 943         ProductRestUtils.checkSuccess(changeStatusResponse);
 944         String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 945         // change uniqueId after product check-out in expected Req&Cap
 946         updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
 947         // CHANGE Service Instance VERSION to service in checkOut state
 948         RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(
 949                 productDetails_01.getUniqueId(), serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, sdncPmDetails1,
 950                 ComponentTypeEnum.PRODUCT, true);
 951         assertEquals("Check response code ", STATUS_CODE_NOT_FOUND,
 952                 changeServiceInstanceVersionResponse.getErrorCode().intValue());
 953         ArrayList<String> varibales = new ArrayList<String>();
 954         varibales.add(serviceNewUniqueUid);
 955         ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.SERVICE_NOT_FOUND.name(), varibales,
 956                 changeServiceInstanceVersionResponse.getResponse());
 957         // Check-in product
 958         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 959                 LifeCycleStatesEnum.CHECKIN);
 960         ProductRestUtils.checkSuccess(changeStatusResponse);
 961         getComponentAndValidateRIs(productDetails_01, 2, 0);
 962         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 963                 LifeCycleStatesEnum.CHECKIN);
 964         ResourceRestUtils.checkSuccess(changeStatusResponse);
 965
 966     }
 967
 968     @Test
 969     public void changeServiceInstanceVersionServiceInstanceDoesNotExist() throws Exception {
 970         // Adding service instance (serviceDetails_01) to product without saving
 971         // Req&Cap
 972         RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01,
 973                 sdncPmDetails1);
 974         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 975         // Adding service instance (serviceDetails_02) to product AND ---> Save
 976         // Req&Cap
 977         createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
 978         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 979         // check-in product
 980         RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 981                 LifeCycleStatesEnum.CHECKIN);
 982         ProductRestUtils.checkSuccess(changeStatusResponse);
 983         String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 984         // Checkout service [0.2]
 985         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 986                 LifeCycleStatesEnum.CHECKOUT);
 987         ResourceRestUtils.checkSuccess(changeStatusResponse);
 988         String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 989         // Check-In service [0.2]
 990         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
 991                 LifeCycleStatesEnum.CHECKIN);
 992         ResourceRestUtils.checkSuccess(changeStatusResponse);
 993         // check-out product
 994         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
 995                 LifeCycleStatesEnum.CHECKOUT);
 996         ProductRestUtils.checkSuccess(changeStatusResponse);
 997         String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
 998         updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
 999         // change service instance to newer version
1000         String serviceUniqueUidNotExist = "1234567890";
1001         RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
1002                 serviceUniqueUidNotExist, serviceNewUniqueUid, sdncPmDetails1, ComponentTypeEnum.PRODUCT, true);
1003         assertEquals("Check response code ", STATUS_CODE_NOT_FOUND,
1004                 changeServiceInstanceVersionResponse.getErrorCode().intValue());
1005         ArrayList<String> varibales = new ArrayList<String>();
1006         varibales.add(serviceUniqueUidNotExist);
1007         ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND.name(), varibales,
1008                 changeServiceInstanceVersionResponse.getResponse());
1009         // Check-in product
1010         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1011                 LifeCycleStatesEnum.CHECKIN);
1012         ProductRestUtils.checkSuccess(changeStatusResponse);
1013         getComponentAndValidateRIs(productDetails_01, 2, 0);
1014     }
1015
1016     // DE189392
1017     @Test(enabled = false)
1018     public void changeServiceInstanceNonExistingProduct() throws Exception {
1019         // Adding service instance (serviceDetails_01) to product saving Req&Cap
1020         RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01,
1021                 sdncPmDetails1);
1022         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1023         // Adding service instance (serviceDetails_02) to product AND ---> Save
1024         // Req&Cap
1025         createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
1026         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1027         // check-in product
1028         RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1029                 LifeCycleStatesEnum.CHECKIN);
1030         ProductRestUtils.checkSuccess(changeStatusResponse);
1031         // Checkout service [0.2]
1032         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1033                 LifeCycleStatesEnum.CHECKOUT);
1034         ResourceRestUtils.checkSuccess(changeStatusResponse);
1035         String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1036         // Check-In service [0.2]
1037         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1038                 LifeCycleStatesEnum.CHECKIN);
1039         ResourceRestUtils.checkSuccess(changeStatusResponse);
1040         // change service instance to newer version - Non existing Product
1041         String productNewUniqueIdNotExist = "1234567890";
1042         RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueIdNotExist,
1043                 serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, sdncPmDetails1, ComponentTypeEnum.PRODUCT, true);
1044         assertEquals("Check response code ", STATUS_CODE_NOT_FOUND,
1045                 changeServiceInstanceVersionResponse.getErrorCode().intValue());
1046         ArrayList<String> varibales = new ArrayList<String>();
1047         varibales.add(productNewUniqueIdNotExist);
1048         ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND.name(), varibales,
1049                 changeServiceInstanceVersionResponse.getResponse());
1050         getComponentAndValidateRIs(productDetails_01, 2, 0);
1051     }
1052
1053     @Test
1054     public void changeServiceInstanceVersionToNonExisitingServiceVersion() throws Exception {
1055         // Adding service instance (serviceDetails_01) to product saving Req&Cap
1056         RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01,
1057                 sdncPmDetails1);
1058         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1059         // Adding service instance (serviceDetails_02) to product AND ---> Save
1060         // Req&Cap
1061         createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
1062         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1063         // check-in product
1064         RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1065                 LifeCycleStatesEnum.CHECKIN);
1066         ProductRestUtils.checkSuccess(changeStatusResponse);
1067         String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1068         // check-out product
1069         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1070                 LifeCycleStatesEnum.CHECKOUT);
1071         ProductRestUtils.checkSuccess(changeStatusResponse);
1072         String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1073         updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
1074         // get service instance new uniqueId , name and position after checkout
1075         // product
1076         updateNewComponentInstanceId(createServiceInstanceResp, productNewUniqueId);
1077         updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
1078         // change service instance to Non-existing version
1079         String serviceUniqueUidNotExist = "1234567890";
1080         RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
1081                 serviceInstanceToReplaceUniqueId, serviceUniqueUidNotExist, sdncPmDetails1, ComponentTypeEnum.PRODUCT,
1082                 true);
1083         assertEquals("Check response code ", STATUS_CODE_NOT_FOUND,
1084                 changeServiceInstanceVersionResponse.getErrorCode().intValue());
1085         ArrayList<String> varibales = new ArrayList<String>();
1086         varibales.add(serviceUniqueUidNotExist);
1087         ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESOURCE_NOT_FOUND.name(), varibales,
1088                 changeServiceInstanceVersionResponse.getResponse());
1089         getComponentAndValidateRIs(productDetails_01, 2, 0);
1090     }
1091
1092     @Test
1093     public void changeServiceInstanceComponentTypeIsNotProduct() throws Exception {
1094         // Adding service instance (serviceDetails_01) to product without saving
1095         // Req&Cap
1096         RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01,
1097                 sdncPmDetails1);
1098         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1099         String firstServiceInstanceNormalizedName = ResponseParser
1100                 .getValueFromJsonResponse(createServiceInstanceResp.getResponse(), "normalizedName");
1101         // Adding service instance (serviceDetails_02) to product AND ---> Save
1102         // Req&Cap
1103         createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
1104         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1105         // check-in product
1106         RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1107                 LifeCycleStatesEnum.CHECKIN);
1108         ProductRestUtils.checkSuccess(changeStatusResponse);
1109         String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1110         // Checkout service [0.2]
1111         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1112                 LifeCycleStatesEnum.CHECKOUT);
1113         ResourceRestUtils.checkSuccess(changeStatusResponse);
1114         String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1115         serviceDetails_01.setUniqueId(serviceNewUniqueUid);
1116         // Check-In service [0.2]
1117         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1118                 LifeCycleStatesEnum.CHECKIN);
1119         ResourceRestUtils.checkSuccess(changeStatusResponse);
1120         // check-out product
1121         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1122                 LifeCycleStatesEnum.CHECKOUT);
1123         ProductRestUtils.checkSuccess(changeStatusResponse);
1124         String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1125         updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
1126         // get service instance new uniqueId , name and position after checkout
1127         // product
1128         RestResponse getProductResponse = ProductRestUtils.getProduct(productNewUniqueId, sdncPmDetails1.getUserId());
1129         Product product = ResponseParser.parseToObjectUsingMapper(getProductResponse.getResponse(), Product.class);
1130         List<ComponentInstance> componentInstances = product.getComponentInstances();
1131         for (ComponentInstance component : componentInstances) {
1132             if (component.getNormalizedName().equals(firstServiceInstanceNormalizedName)) {
1133                 serviceInstanceToReplaceUniqueId = component.getUniqueId();
1134             }
1135         }
1136         assertTrue(serviceInstanceToReplaceUniqueId != null);
1137         // change service instance to newer version for NON-Component Type =
1138         // Product (e.g. service)
1139         RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
1140                 serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, sdncPmDetails1, ComponentTypeEnum.SERVICE, true);
1141         assertEquals("Check response code ", STATUS_CODE_NOT_FOUND,
1142                 changeServiceInstanceVersionResponse.getErrorCode().intValue());
1143         ArrayList<String> varibales = new ArrayList<String>();
1144         varibales.add("");
1145         ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.SERVICE_NOT_FOUND.name(), varibales,
1146                 changeServiceInstanceVersionResponse.getResponse());
1147         getComponentAndValidateRIs(productDetails_01, 2, 0);
1148     }
1149
1150     @Test
1151     public void changeServiceInstanceComponentTypeNotSupported() throws Exception {
1152         // Adding service instance (serviceDetails_01) to product without saving
1153         // Req&Cap
1154         RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01,
1155                 sdncPmDetails1);
1156         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1157         String firstServiceInstanceNormalizedName = ResponseParser
1158                 .getValueFromJsonResponse(createServiceInstanceResp.getResponse(), "normalizedName");
1159         // Adding service instance (serviceDetails_02) to product AND ---> Save
1160         // Req&Cap
1161         createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
1162         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1163         // check-in product
1164         RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1165                 LifeCycleStatesEnum.CHECKIN);
1166         ProductRestUtils.checkSuccess(changeStatusResponse);
1167         String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1168         // Checkout service [0.2]
1169         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1170                 LifeCycleStatesEnum.CHECKOUT);
1171         ResourceRestUtils.checkSuccess(changeStatusResponse);
1172         String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1173         serviceDetails_01.setUniqueId(serviceNewUniqueUid);
1174         // Check-In service [0.2]
1175         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1176                 LifeCycleStatesEnum.CHECKIN);
1177         ResourceRestUtils.checkSuccess(changeStatusResponse);
1178         // check-out product
1179         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1180                 LifeCycleStatesEnum.CHECKOUT);
1181         ProductRestUtils.checkSuccess(changeStatusResponse);
1182         String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1183         updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
1184         // get service instance new uniqueId , name and position after checkout
1185         // product
1186         RestResponse getProductResponse = ProductRestUtils.getProduct(productNewUniqueId, sdncPmDetails1.getUserId());
1187         Product product = ResponseParser.parseToObjectUsingMapper(getProductResponse.getResponse(), Product.class);
1188         List<ComponentInstance> componentInstances = product.getComponentInstances();
1189         for (ComponentInstance component : componentInstances) {
1190             if (component.getNormalizedName().equals(firstServiceInstanceNormalizedName)) {
1191                 serviceInstanceToReplaceUniqueId = component.getUniqueId();
1192             }
1193         }
1194         assertTrue(serviceInstanceToReplaceUniqueId != null);
1195         // change service instance to newer version for NON-Component Type =
1196         // Product (e.g. service)
1197         RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
1198                 serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, sdncPmDetails1,
1199                 ComponentTypeEnum.SERVICE_INSTANCE, true);
1200         assertEquals("Check response code ", STATUS_CODE_UNSUPPORTED_ERROR,
1201                 changeServiceInstanceVersionResponse.getErrorCode().intValue());
1202         ArrayList<String> varibales = new ArrayList<String>();
1203         varibales.add("null");
1204         ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.UNSUPPORTED_ERROR.name(), varibales,
1205                 changeServiceInstanceVersionResponse.getResponse());
1206         getComponentAndValidateRIs(productDetails_01, 2, 0);
1207     }
1208
1209     @Test
1210     public void SeveralServiceInstanceFromSameServiceVersionChangeVersionOnlyForOneServiceInstance() throws Exception {
1211         // Adding service instance (serviceDetails_01) to product without saving
1212         // Req&Cap
1213         RestResponse createServiceInstanceResp = createServiceInstanceDuringSetup(productDetails_01, serviceDetails_01,
1214                 sdncPmDetails1);
1215         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1216         String firstServiceInstanceNormalizedName = ResponseParser
1217                 .getValueFromJsonResponse(createServiceInstanceResp.getResponse(), "normalizedName");
1218         // Adding service instance (serviceDetails_02) to product AND ---> Save
1219         // Req&Cap
1220         createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
1221         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1222         // check-in product
1223         RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1224                 LifeCycleStatesEnum.CHECKIN);
1225         ProductRestUtils.checkSuccess(changeStatusResponse);
1226         String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1227         // Checkout service [0.2]
1228         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1229                 LifeCycleStatesEnum.CHECKOUT);
1230         ResourceRestUtils.checkSuccess(changeStatusResponse);
1231         String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1232         serviceDetails_01.setUniqueId(serviceNewUniqueUid);
1233         // get the new VF instance uniqueId after checkout service
1234         RestResponse getServiceResponse = ServiceRestUtils.getService(serviceDetails_01.getUniqueId(), sdncPmDetails1);
1235         Service service = ResponseParser.parseToObjectUsingMapper(getServiceResponse.getResponse(), Service.class);
1236         List<ComponentInstance> serviceComponentInstances = service.getComponentInstances();
1237         for (ComponentInstance component : serviceComponentInstances) {
1238             if (component.getName().equals(firstVfInstanceName)) {
1239                 firstVfInstanceUniqueId = component.getUniqueId();
1240             }
1241         }
1242         assertTrue(firstVfInstanceUniqueId != null);
1243         // delete resource instance (resourceDetailsVF_01) from Service
1244         RestResponse deleteVfFromServiceResponse = deleteVFInstanceDuringSetup(firstVfInstanceUniqueId,
1245                 serviceDetails_01, sdncDesignerDetails);
1246         assertTrue(deleteVfFromServiceResponse.getErrorCode() == STATUS_CODE_SUCCESS_DELETE);
1247         // Add different VF instance (resourceDetailsVF_02) to Service
1248         RestResponse restResponse = createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF_02,
1249                 sdncDesignerDetails);
1250         ResourceRestUtils.checkCreateResponse(restResponse);
1251         // Check-In service [0.2]
1252         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1253                 LifeCycleStatesEnum.CHECKIN);
1254         ResourceRestUtils.checkSuccess(changeStatusResponse);
1255         // check-out product
1256         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1257                 LifeCycleStatesEnum.CHECKOUT);
1258         ProductRestUtils.checkSuccess(changeStatusResponse);
1259         String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1260         updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
1261         // get service instance new uniqueId , name and position after checkout
1262         // product
1263         RestResponse getProductResponse = ProductRestUtils.getProduct(productNewUniqueId, sdncPmDetails1.getUserId());
1264         Product product = ResponseParser.parseToObjectUsingMapper(getProductResponse.getResponse(), Product.class);
1265         List<ComponentInstance> componentInstances = product.getComponentInstances();
1266         for (ComponentInstance component : componentInstances) {
1267             if (component.getNormalizedName().equals(firstServiceInstanceNormalizedName)) {
1268                 serviceInstanceToReplaceUniqueId = component.getUniqueId();
1269                 expectedServiceName = component.getName();
1270                 expectedPosX = component.getPosX();
1271                 expectedPosY = component.getPosY();
1272             }
1273         }
1274         assertTrue(serviceInstanceToReplaceUniqueId != null);
1275         // change service instance to newer version
1276         RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
1277                 serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, sdncPmDetails1, ComponentTypeEnum.PRODUCT, true);
1278         ProductRestUtils.checkSuccess(changeServiceInstanceVersionResponse);
1279         actualServiceInstanceName = ResponseParser.getNameFromResponse(changeServiceInstanceVersionResponse);
1280         actualPosX = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
1281                 "posX");
1282         actualPosY = ResponseParser.getValueFromJsonResponse(changeServiceInstanceVersionResponse.getResponse(),
1283                 "posY");
1284         ComponentInstance componentInstance = ResponseParser
1285                 .parseToObjectUsingMapper(changeServiceInstanceVersionResponse.getResponse(), ComponentInstance.class);
1286         addCompInstReqCapToExpected(componentInstance, ComponentTypeEnum.PRODUCT);
1287         // Check-in product
1288         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1289                 LifeCycleStatesEnum.CHECKIN);
1290         ProductRestUtils.checkSuccess(changeStatusResponse);
1291         getComponentAndValidateRIs(productDetails_01, 2, 0);
1292         // Verify that Service instance name and position didn't change after
1293         // changing service instance version
1294         assertTrue(actualServiceInstanceName.equals(expectedServiceName));
1295         assertTrue(actualPosX.equals(expectedPosX));
1296         assertTrue(actualPosY.equals(expectedPosY));
1297     }
1298
1299     @Test
1300     public void changeServiceInstanceVersionByNonAsdcUser() throws Exception {
1301         // Adding service instance (serviceDetails_01) to product without saving
1302         // Req&Cap
1303         RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01,
1304                 sdncPmDetails1);
1305         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1306         // Adding service instance (serviceDetails_02) to product AND ---> Save
1307         // Req&Cap
1308         createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
1309         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1310         // check-in product
1311         RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1312                 LifeCycleStatesEnum.CHECKIN);
1313         ProductRestUtils.checkSuccess(changeStatusResponse);
1314         String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1315         // Checkout service [0.2]
1316         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1317                 LifeCycleStatesEnum.CHECKOUT);
1318         ResourceRestUtils.checkSuccess(changeStatusResponse);
1319         String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1320         // Check-In service [0.2]
1321         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1322                 LifeCycleStatesEnum.CHECKIN);
1323         ResourceRestUtils.checkSuccess(changeStatusResponse);
1324         // check-out product
1325         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1326                 LifeCycleStatesEnum.CHECKOUT);
1327         ProductRestUtils.checkSuccess(changeStatusResponse);
1328         String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1329         updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
1330         User nonAsdcUser = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1331         nonAsdcUser.setUserId("bt760h");
1332         // change service instance to newer version
1333         RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
1334                 serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, nonAsdcUser, ComponentTypeEnum.PRODUCT, true);
1335         assertEquals("Check response code ", STATUS_CODE_RESTRICTED_OPERATION,
1336                 changeServiceInstanceVersionResponse.getErrorCode().intValue());
1337         ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
1338                 changeServiceInstanceVersionResponse.getResponse());
1339         // Check-in product
1340         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1341                 LifeCycleStatesEnum.CHECKIN);
1342         ProductRestUtils.checkSuccess(changeStatusResponse);
1343         getComponentAndValidateRIs(productDetails_01, 2, 0);
1344     }
1345
1346     @Test
1347     public void changeServiceInstanceVersionEmptyUserId() throws Exception {
1348         // Adding service instance (serviceDetails_01) to product without saving
1349         // Req&Cap
1350         RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01,
1351                 sdncPmDetails1);
1352         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1353         // Adding service instance (serviceDetails_02) to product AND ---> Save
1354         // Req&Cap
1355         createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
1356         ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1357         // check-in product
1358         RestResponse changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1359                 LifeCycleStatesEnum.CHECKIN);
1360         ProductRestUtils.checkSuccess(changeStatusResponse);
1361         String productOldUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1362         // Checkout service [0.2]
1363         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1364                 LifeCycleStatesEnum.CHECKOUT);
1365         ResourceRestUtils.checkSuccess(changeStatusResponse);
1366         String serviceNewUniqueUid = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1367         // Check-In service [0.2]
1368         changeStatusResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails,
1369                 LifeCycleStatesEnum.CHECKIN);
1370         ResourceRestUtils.checkSuccess(changeStatusResponse);
1371         // check-out product
1372         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1373                 LifeCycleStatesEnum.CHECKOUT);
1374         ProductRestUtils.checkSuccess(changeStatusResponse);
1375         String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(changeStatusResponse);
1376         updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
1377         User nonAsdcUser = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1378         nonAsdcUser.setUserId("");
1379         // change service instance to newer version
1380         RestResponse changeServiceInstanceVersionResponse = changeServiceInstanceVersion(productNewUniqueId,
1381                 serviceInstanceToReplaceUniqueId, serviceNewUniqueUid, nonAsdcUser, ComponentTypeEnum.PRODUCT, true);
1382         assertEquals("Check response code ", STATUS_CODE_MISSING_INFORMATION,
1383                 changeServiceInstanceVersionResponse.getErrorCode().intValue());
1384         ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_INFORMATION.name(), new ArrayList<String>(),
1385                 changeServiceInstanceVersionResponse.getResponse());
1386         // Check-in product
1387         changeStatusResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1,
1388                 LifeCycleStatesEnum.CHECKIN);
1389         ProductRestUtils.checkSuccess(changeStatusResponse);
1390         getComponentAndValidateRIs(productDetails_01, 2, 0);
1391     }
1392
1393     ////////////////////////////////////
1394     private void updateNewComponentInstanceId(RestResponse createServiceInstanceResp, String productNewUniqueId)
1395             throws Exception {
1396         String firstServiceInstanceNormalizedName = ResponseParser
1397                 .getValueFromJsonResponse(createServiceInstanceResp.getResponse(), "normalizedName");
1398         RestResponse getProductResponse = ProductRestUtils.getProduct(productNewUniqueId, sdncPmDetails1.getUserId());
1399         Product product = ResponseParser.parseToObjectUsingMapper(getProductResponse.getResponse(), Product.class);
1400         List<ComponentInstance> componentInstances = product.getComponentInstances();
1401         for (ComponentInstance component : componentInstances) {
1402             if (component.getNormalizedName().equals(firstServiceInstanceNormalizedName)) {
1403                 serviceInstanceToReplaceUniqueId = component.getUniqueId();
1404                 expectedServiceName = component.getName();
1405                 expectedPosX = component.getPosX();
1406                 expectedPosY = component.getPosY();
1407             }
1408         }
1409         assertTrue(serviceInstanceToReplaceUniqueId != null);
1410     }
1411
1412     private RestResponse changeResourceStateToCertified(ResourceReqDetails resourceDetails) throws Exception {
1413         RestResponse restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, sdncDesignerDetails,
1414                 LifeCycleStatesEnum.CHECKIN);
1415         ResourceRestUtils.checkSuccess(restResponse);
1416                 /*restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, sdncDesignerDetails,
1417                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1418                 if (restResponse.getErrorCode() == 200) {
1419                         restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, sdncTesterDetails,
1420                                         LifeCycleStatesEnum.STARTCERTIFICATION);
1421                 } else
1422                         return restResponse;
1423                 if (restResponse.getErrorCode() == 200) {*/
1424         restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, sdncDesignerDetails,
1425                 LifeCycleStatesEnum.CERTIFY);
1426         if (restResponse.getErrorCode() == 200) {
1427             String newVersion = ResponseParser.getVersionFromResponse(restResponse);
1428             resourceDetails.setVersion(newVersion);
1429             resourceDetails.setLifecycleState(LifecycleStateEnum.CERTIFIED);
1430             resourceDetails.setLastUpdaterUserId(sdncTesterDetails.getUserId());
1431             resourceDetails.setLastUpdaterFullName(sdncTesterDetails.getFullName());
1432             String uniqueIdFromRresponse = ResponseParser.getValueFromJsonResponse(restResponse.getResponse(),
1433                     "uniqueId");
1434             resourceDetails.setUniqueId(uniqueIdFromRresponse);
1435         }
1436         return restResponse;
1437     }
1438
1439     private void certifyVf(ResourceReqDetails resource, ResourceReqDetails computeResource,
1440                            ResourceReqDetails cpResource) throws Exception {
1441         RestResponse createAtomicResourceInstance = createAtomicInstanceForVFDuringSetup(resource, cpResource,
1442                 sdncDesignerDetails);
1443         ResourceRestUtils.checkCreateResponse(createAtomicResourceInstance);
1444         String fromCompInstId = ResponseParser.getUniqueIdFromResponse(createAtomicResourceInstance);
1445
1446         createAtomicResourceInstance = createAtomicInstanceForVFDuringSetup(resource, computeResource,
1447                 sdncDesignerDetails);
1448         ResourceRestUtils.checkCreateResponse(createAtomicResourceInstance);
1449         String toCompInstId = ResponseParser.getUniqueIdFromResponse(createAtomicResourceInstance);
1450
1451         RestResponse response = ArtifactRestUtils.addInformationalArtifactToResource(heatArtifactDetails,
1452                 sdncDesignerDetails, resource.getUniqueId());
1453         ResourceRestUtils.checkSuccess(response);
1454
1455         String capOwnerId = toCompInstId;
1456         User user = sdncDesignerDetails;
1457         ComponentTypeEnum containerCompType = ComponentTypeEnum.RESOURCE;
1458
1459         fulfillCpRequirement(resource, fromCompInstId, toCompInstId, capOwnerId, user, containerCompType);
1460
1461         RestResponse changeResourceStateToCertified = changeResourceStateToCertified(resource);
1462         ResourceRestUtils.checkSuccess(changeResourceStateToCertified);
1463     }
1464 }