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