asdc-tests/src/main/java/org/openecomp/sdc/ci/tests/execute/product/ProductComponentInstanceCRUDTest.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_ALREADY_EXISTS;
  24 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_COMPONENT_NAME_EXCEEDS_LIMIT;
  25 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_INVALID_CONTENT;
  26 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_MISSING_INFORMATION;
  27 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_NOT_FOUND;
  28 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION;
  29 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_SUCCESS_DELETE;
  30 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_UNSUPPORTED_ERROR;
  31 import static org.testng.AssertJUnit.assertEquals;
  32 import static org.testng.AssertJUnit.assertTrue;
  33
  34 import java.util.ArrayList;
  35 import java.util.List;
  36
  37 import org.junit.Rule;
  38 import org.junit.rules.TestName;
  39 import org.openecomp.sdc.be.dao.api.ActionStatus;
  40 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  41 import org.openecomp.sdc.be.model.ComponentInstance;
  42 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  43 import org.openecomp.sdc.be.model.Product;
  44 import org.openecomp.sdc.be.model.User;
  45 import org.openecomp.sdc.ci.tests.api.ComponentInstanceBaseTest;
  46 import org.openecomp.sdc.ci.tests.datatypes.ArtifactReqDetails;
  47 import org.openecomp.sdc.ci.tests.datatypes.ComponentInstanceReqDetails;
  48 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  49 import org.openecomp.sdc.ci.tests.datatypes.ServiceReqDetails;
  50 import org.openecomp.sdc.ci.tests.datatypes.enums.ArtifactTypeEnum;
  51 import org.openecomp.sdc.ci.tests.datatypes.enums.LifeCycleStatesEnum;
  52 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  53 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  54 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  55 import org.openecomp.sdc.ci.tests.utils.rest.ArtifactRestUtils;
  56 import org.openecomp.sdc.ci.tests.utils.rest.ComponentInstanceRestUtils;
  57 import org.openecomp.sdc.ci.tests.utils.rest.LifecycleRestUtils;
  58 import org.openecomp.sdc.ci.tests.utils.rest.ProductRestUtils;
  59 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils;
  60 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  61 import org.openecomp.sdc.ci.tests.utils.rest.ServiceRestUtils;
  62 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  63 import org.testng.AssertJUnit;
  64 import org.testng.annotations.BeforeMethod;
  65 import org.testng.annotations.Test;
  66
  67 public class ProductComponentInstanceCRUDTest extends ComponentInstanceBaseTest {
  68
  69         protected ArtifactReqDetails heatArtifactDetails;
  70         @Rule
  71         public static TestName name = new TestName();
  72
  73         public ProductComponentInstanceCRUDTest() {
  74                 super(name, ProductComponentInstanceCRUDTest.class.getName());
  75         }
  76
  77         @BeforeMethod
  78         public void before() throws Exception {
  79                 init();
  80                 createComponents();
  81         }
  82
  83         private void createComponents() throws Exception {
  84
  85                 heatArtifactDetails = ElementFactory.getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
  86                 createAtomicResource(resourceDetailsVFC_01);
  87                 changeResourceStateToCertified(resourceDetailsVFC_01);
  88                 createAtomicResource(resourceDetailsCP_01);
  89                 changeResourceStateToCertified(resourceDetailsCP_01);
  90                 createAtomicResource(resourceDetailsVL_01);
  91                 changeResourceStateToCertified(resourceDetailsVL_01);
  92                 createAtomicResource(resourceDetailsVFC_02);
  93                 changeResourceStateToCertified(resourceDetailsVFC_02);
  94                 createAtomicResource(resourceDetailsCP_02);
  95                 changeResourceStateToCertified(resourceDetailsCP_02);
  96                 createAtomicResource(resourceDetailsVL_02);
  97                 changeResourceStateToCertified(resourceDetailsVL_02);
  98                 createVF(resourceDetailsVF_02);
  99                 createVF(resourceDetailsVF_01);
 100                 // create check-In services
 101                 createService(serviceDetails_01);
 102                 createService(serviceDetails_02);
 103                 createService(serviceDetails_03);
 104                 createProduct(productDetails_01);
 105                 createProduct(productDetails_02);
 106
 107                 // addresourceDetailsCP_02 ,resourceDetailsVFC_02 and
 108                 // resourceDetailsVL_02 to resourceDetailsVF_02 check-in VF
 109                 RestResponse createAtomicResourceInstance = createAtomicInstanceForVFDuringSetup(resourceDetailsVF_02, resourceDetailsVFC_02, sdncDesignerDetails);
 110                 ResourceRestUtils.checkCreateResponse(createAtomicResourceInstance);
 111                 createAtomicResourceInstance = createAtomicInstanceForVFDuringSetup(resourceDetailsVF_02, resourceDetailsCP_02, sdncDesignerDetails);
 112                 ResourceRestUtils.checkCreateResponse(createAtomicResourceInstance);
 113                 createAtomicResourceInstance = createAtomicInstanceForVFDuringSetup(resourceDetailsVF_02, resourceDetailsVL_02, sdncDesignerDetails);
 114                 ResourceRestUtils.checkCreateResponse(createAtomicResourceInstance);
 115                 RestResponse restResponse = LifecycleRestUtils.changeResourceState(resourceDetailsVF_02, sdncDesignerDetails, LifeCycleStatesEnum.CHECKIN);
 116                 resourceDetailsVF_02.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
 117                 // addresourceDetailsCP_01 ,resourceDetailsVFC_01 and
 118                 // resourceDetailsVL_01 to resourceDetailsVF_01 and certify
 119                 // resourceDetailsVF_01
 120                 certifyVf(resourceDetailsVF_01);
 121                 createVFInstanceDuringSetup(serviceDetails_01, resourceDetailsVF_01, sdncDesignerDetails); // serviceDetails_01
 122                                                                                                                                                                                                         // has
 123                                                                                                                                                                                                         // certified
 124                                                                                                                                                                                                         // VF
 125                 createVFInstanceDuringSetup(serviceDetails_02, resourceDetailsVF_02, sdncDesignerDetails); // serviceDetails_02
 126                                                                                                                                                                                                         // has
 127                                                                                                                                                                                                         // check-in
 128                                                                                                                                                                                                         // VF
 129                 restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails, LifeCycleStatesEnum.CHECKIN);
 130                 ResourceRestUtils.checkSuccess(restResponse);
 131                 restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_02, sdncDesignerDetails, LifeCycleStatesEnum.CHECKIN);
 132                 ResourceRestUtils.checkSuccess(restResponse);
 133         }
 134
 135         // pass
 136         @Test
 137         public void createServiceInstanceTest() throws Exception {
 138                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 139                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 140                 getComponentAndValidateRIs(productDetails_01, 1, 0);
 141         }
 142
 143         // DE189427
 144         @Test(enabled = false)
 145         public void createServiceInstanceFromCheckedOutState() throws Exception {
 146                 // can't create instance of checked-out component
 147                 RestResponse restResponse = LifecycleRestUtils.changeServiceState(serviceDetails_01, sdncDesignerDetails, LifeCycleStatesEnum.CHECKOUT);
 148                 ResourceRestUtils.checkSuccess(restResponse);
 149                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 150                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 151                 getComponentAndValidateRIs(productDetails_01, 1, 0);
 152         }
 153
 154         @Test
 155         public void createServiceInstanceInToAnotherServiceInstance() throws Exception {
 156                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
 157                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 158                 String uniqueIdFromResponse = ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
 159                 getComponentAndValidateRIs(productDetails_01, 1, 0);
 160                 ComponentInstanceReqDetails serviceInstanceReqDetails = ElementFactory.getComponentResourceInstance(serviceDetails_01);
 161                 createServiceInstanceResp = ComponentInstanceRestUtils.createComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, uniqueIdFromResponse, ComponentTypeEnum.PRODUCT);
 162                 assertTrue(createServiceInstanceResp.getErrorCode() == STATUS_CODE_NOT_FOUND);
 163         }
 164
 165         @Test
 166         public void createSeveralServiceInstanceFromSameServices() throws Exception {
 167                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 168                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 169                 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 170                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 171                 getComponentAndValidateRIs(productDetails_01, 2, 0);
 172         }
 173
 174         @Test
 175         public void createSeveralServiceInstanceFromDifferentServices() throws Exception {
 176                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 177                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 178                 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
 179                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 180                 getComponentAndValidateRIs(productDetails_01, 2, 0);
 181         }
 182
 183         @Test
 184         public void createCertifiedServiceInstance() throws Exception {
 185                 changeServiceStateToCertified(serviceDetails_01);
 186                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 187                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 188                 getComponentAndValidateRIs(productDetails_01, 1, 0);
 189         }
 190
 191         @Test
 192         public void createServiceInstanceByPm() throws Exception {
 193                 RestResponse restResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1, LifeCycleStatesEnum.CHECKIN);
 194                 ResourceRestUtils.checkSuccess(restResponse);
 195                 restResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1, LifeCycleStatesEnum.CHECKOUT);
 196                 ResourceRestUtils.checkSuccess(restResponse);
 197                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 198                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 199                 getComponentAndValidateRIs(productDetails_01, 1, 0);
 200         }
 201
 202         @Test
 203         public void createServiceInstanceWithoutVf() throws Exception {
 204                 LifecycleRestUtils.changeServiceState(serviceDetails_03, sdncAdminDetails, "0.1", LifeCycleStatesEnum.CHECKIN);
 205                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_02, serviceDetails_03, sdncPmDetails1);
 206                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 207                 getComponentAndValidateRIs(productDetails_02, 1, 0);
 208         }
 209
 210         @Test
 211         public void createServiceInstanceByNonProductOwner() throws Exception {
 212                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 213                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 214                 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails2);
 215                 assertTrue(createServiceInstanceResp.getErrorCode() == STATUS_CODE_RESTRICTED_OPERATION);
 216                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(), createServiceInstanceResp.getResponse());
 217                 getComponentAndValidateRIs(productDetails_01, 1, 0);
 218         }
 219
 220         @Test
 221         public void createServiceInstanceByNonAsdcUser() throws Exception {
 222                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 223                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 224                 User nonExistingSdncUser = ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1);
 225                 ;
 226                 nonExistingSdncUser.setUserId("bt1234");
 227                 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, nonExistingSdncUser);
 228                 assertTrue(createServiceInstanceResp.getErrorCode() == STATUS_CODE_RESTRICTED_OPERATION);
 229                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(), createServiceInstanceResp.getResponse());
 230                 getComponentAndValidateRIs(productDetails_01, 1, 0);
 231         }
 232
 233         @Test
 234         public void createServiceInstanceToNotCheckOutProduct() throws Exception {
 235                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 236                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 237                 RestResponse restResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1, LifeCycleStatesEnum.CHECKIN);
 238                 ResourceRestUtils.checkSuccess(restResponse);
 239                 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 240                 assertTrue(createServiceInstanceResp.getErrorCode() == STATUS_CODE_RESTRICTED_OPERATION);
 241                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(), createServiceInstanceResp.getResponse());
 242                 getComponentAndValidateRIs(productDetails_01, 1, 0);
 243         }
 244
 245         // pass
 246         @Test
 247         public void createServiceInstanceNameIsEmpty() throws Exception {
 248                 String expectedServiceInstanceName = serviceDetails_01.getName() + " 1";
 249                 String expectedServiceInstancenormalizedName = serviceDetails_01.getName() + "1";
 250                 serviceDetails_01.setName("");
 251                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 252                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 253                 String instanceNormalizedName = ResponseParser.getValueFromJsonResponse(createServiceInstanceResp.getResponse(), "normalizedName");
 254                 String instanceName = ResponseParser.getValueFromJsonResponse(createServiceInstanceResp.getResponse(), "name");
 255                 assertEquals("check Resource Instance normalizedName ", (expectedServiceInstancenormalizedName).toLowerCase(), instanceNormalizedName);
 256                 assertEquals("check Resource Instance Name ", expectedServiceInstanceName, instanceName);
 257                 getComponentAndValidateRIs(productDetails_01, 1, 0);
 258                 // get product and verify that service instanceName is correct
 259                 RestResponse getActualProductResponse = ProductRestUtils.getProduct(productDetails_01.getUniqueId(), sdncPmDetails1.getUserId());
 260                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getActualProductResponse.getResponse(), Product.class);
 261                 ComponentInstance actualComponentInstance = actualProduct.getComponentInstances().get(0);
 262                 assertEquals(expectedServiceInstanceName, actualComponentInstance.getName());
 263                 assertEquals((expectedServiceInstancenormalizedName).toLowerCase(), actualComponentInstance.getNormalizedName());
 264         }
 265
 266         // pass
 267         @Test
 268         public void createServiceInstanceNameIsNull() throws Exception {
 269                 String expectedServiceInstanceName = serviceDetails_01.getName() + " 1";
 270                 String expectedServiceInstancenormalizedName = serviceDetails_01.getName() + "1";
 271                 serviceDetails_01.setName(null);
 272                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 273                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 274                 String instanceNormalizedName = ResponseParser.getValueFromJsonResponse(createServiceInstanceResp.getResponse(), "normalizedName");
 275                 String instanceName = ResponseParser.getValueFromJsonResponse(createServiceInstanceResp.getResponse(), "name");
 276                 assertEquals("check Resource Instance normalizedName ", (expectedServiceInstancenormalizedName).toLowerCase(), instanceNormalizedName);
 277                 assertEquals("check Resource Instance Name ", expectedServiceInstanceName, instanceName);
 278                 getComponentAndValidateRIs(productDetails_01, 1, 0);
 279                 // get product and verify that service instanceName is correct
 280                 RestResponse getActualProductResponse = ProductRestUtils.getProduct(productDetails_01.getUniqueId(), sdncPmDetails1.getUserId());
 281                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getActualProductResponse.getResponse(), Product.class);
 282                 ComponentInstance actualComponentInstance = actualProduct.getComponentInstances().get(0);
 283                 assertEquals(expectedServiceInstanceName, actualComponentInstance.getName());
 284                 assertEquals((expectedServiceInstancenormalizedName).toLowerCase(), actualComponentInstance.getNormalizedName());
 285         }
 286
 287         @Test(enabled = false)
 288         public void createServiceInstanceToNonExistingProduct() throws Exception {
 289                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 290                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 291                 ComponentInstanceReqDetails serviceInstanceReqDetails = ElementFactory.getComponentResourceInstance(serviceDetails_01);
 292                 createServiceInstanceResp = ComponentInstanceRestUtils.createComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, "blabla", ComponentTypeEnum.PRODUCT);
 293                 AssertJUnit.assertEquals("Check response code ", STATUS_CODE_NOT_FOUND, createServiceInstanceResp.getErrorCode().intValue());
 294                 ArrayList<String> varibales = new ArrayList<String>();
 295                 varibales.add("blabla");
 296                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.PRODUCT_NOT_FOUND.name(), varibales, createServiceInstanceResp.getResponse());
 297                 getComponentAndValidateRIs(productDetails_01, 1, 0);
 298         }
 299
 300         @Test
 301         public void createServiceInstanceToNonSupportedComponentType() throws Exception {
 302                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 303                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 304                 ComponentInstanceReqDetails serviceInstanceReqDetails = ElementFactory.getComponentResourceInstance(serviceDetails_01);
 305                 createServiceInstanceResp = ComponentInstanceRestUtils.createComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.RESOURCE_INSTANCE);
 306                 assertTrue(createServiceInstanceResp.getErrorCode() == STATUS_CODE_UNSUPPORTED_ERROR);
 307                 ArrayList<String> varibales = new ArrayList<String>();
 308                 varibales.add("null");
 309                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.UNSUPPORTED_ERROR.name(), varibales, createServiceInstanceResp.getResponse());
 310                 getComponentAndValidateRIs(productDetails_01, 1, 0);
 311         }
 312
 313         // pass
 314         @Test
 315         public void createServiceInstancePositionIsEmpty() throws Exception {
 316                 ComponentInstanceReqDetails serviceInstanceReqDetails = ElementFactory.getComponentResourceInstance(serviceDetails_01);
 317                 serviceInstanceReqDetails.setPosX("");
 318                 serviceInstanceReqDetails.setPosY("");
 319                 RestResponse createServiceInstanceResp = ComponentInstanceRestUtils.createComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 320                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 321                 ComponentInstance componentInstance = ResponseParser.parseToObjectUsingMapper(createServiceInstanceResp.getResponse(), ComponentInstance.class);
 322                 addCompInstReqCapToExpected(componentInstance, ComponentTypeEnum.PRODUCT);
 323                 getComponentAndValidateRIs(productDetails_01, 1, 0);
 324         }
 325
 326         @Test
 327         public void createServiceInstancePositionIsNull() throws Exception {
 328                 ComponentInstanceReqDetails serviceInstanceReqDetails = ElementFactory.getComponentResourceInstance(serviceDetails_01);
 329                 serviceInstanceReqDetails.setPosX(null);
 330                 serviceInstanceReqDetails.setPosY(null);
 331                 RestResponse createServiceInstanceResp = ComponentInstanceRestUtils.createComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 332                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 333                 ComponentInstance componentInstance = ResponseParser.parseToObjectUsingMapper(createServiceInstanceResp.getResponse(), ComponentInstance.class);
 334                 addCompInstReqCapToExpected(componentInstance, ComponentTypeEnum.PRODUCT);
 335                 getComponentAndValidateRIs(productDetails_01, 1, 0);
 336         }
 337
 338         @Test
 339         public void createServiceInstanceByDesigner() throws Exception {
 340                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 341                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 342                 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncDesignerDetails);
 343                 assertTrue(createServiceInstanceResp.getErrorCode() == STATUS_CODE_RESTRICTED_OPERATION);
 344                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(), createServiceInstanceResp.getResponse());
 345                 getComponentAndValidateRIs(productDetails_01, 1, 0);
 346         }
 347
 348         @Test
 349         public void createServiceInstanceUserIdIsEmpty() throws Exception {
 350                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 351                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 352                 User nonSdncDetails = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
 353                 nonSdncDetails.setUserId("");
 354                 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, nonSdncDetails);
 355                 assertTrue(createServiceInstanceResp.getErrorCode() == STATUS_CODE_MISSING_INFORMATION);
 356                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_INFORMATION.name(), new ArrayList<String>(), createServiceInstanceResp.getResponse());
 357                 getComponentAndValidateRIs(productDetails_01, 1, 0);
 358         }
 359
 360         //// Update Service instance
 361
 362         @Test
 363         public void updateServiceInstanceNameByPm() throws Exception {
 364                 // Check-in Product by PM and Check-out by PM
 365                 RestResponse restResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1, LifeCycleStatesEnum.CHECKIN);
 366                 ResourceRestUtils.checkSuccess(restResponse);
 367                 restResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1, LifeCycleStatesEnum.CHECKOUT);
 368                 ResourceRestUtils.checkSuccess(restResponse);
 369                 // Create service instance by PM
 370                 ComponentInstanceReqDetails serviceInstanceReqDetails = ElementFactory.getComponentResourceInstance(serviceDetails_01);
 371                 RestResponse createServiceInstanceResp = ComponentInstanceRestUtils.createComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 372                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 373                 String newName = "abcD";
 374                 serviceInstanceReqDetails.setName(newName);
 375                 RestResponse updateServiceInstanceResponse = ComponentInstanceRestUtils.updateComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 376                 ResourceRestUtils.checkSuccess(updateServiceInstanceResponse);
 377                 String instanceNormalizedName = ResponseParser.getValueFromJsonResponse(updateServiceInstanceResponse.getResponse(), "normalizedName");
 378                 String instanceName = ResponseParser.getValueFromJsonResponse(updateServiceInstanceResponse.getResponse(), "name");
 379                 assertEquals("check Resource Instance normalizedName ", (newName).toLowerCase(), instanceNormalizedName);
 380                 assertEquals("check Resource Instance Name ", newName, instanceName);
 381                 // get product and verify that service instanceName is correct
 382                 RestResponse getActualProductResponse = ProductRestUtils.getProduct(productDetails_01.getUniqueId(), sdncPmDetails1.getUserId());
 383                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getActualProductResponse.getResponse(), Product.class);
 384                 ComponentInstance actualComponentInstance = actualProduct.getComponentInstances().get(0);
 385                 assertEquals(newName, actualComponentInstance.getName());
 386                 assertEquals((newName).toLowerCase(), actualComponentInstance.getNormalizedName());
 387         }
 388
 389         @Test
 390         public void updateServiceInstanceNewNameAndLocation() throws Exception {
 391                 ComponentInstanceReqDetails serviceInstanceReqDetails = ElementFactory.getComponentResourceInstance(serviceDetails_01);
 392                 RestResponse createServiceInstanceResp = ComponentInstanceRestUtils.createComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 393                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 394                 String newName = "updaatedName100";
 395                 serviceInstanceReqDetails.setPosX("100");
 396                 serviceInstanceReqDetails.setPosY("100");
 397                 serviceInstanceReqDetails.setName(newName);
 398                 RestResponse updateServiceInstanceResponse = ComponentInstanceRestUtils.updateComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 399                 ResourceRestUtils.checkSuccess(updateServiceInstanceResponse);
 400                 // get product and verify that service instanceName is correct
 401                 RestResponse getActualProductResponse = ProductRestUtils.getProduct(productDetails_01.getUniqueId(), sdncPmDetails1.getUserId());
 402                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getActualProductResponse.getResponse(), Product.class);
 403                 ComponentInstance actualComponentInstance = actualProduct.getComponentInstances().get(0);
 404                 assertEquals(serviceInstanceReqDetails.getPosX(), actualComponentInstance.getPosX());
 405                 assertEquals(serviceInstanceReqDetails.getPosY(), actualComponentInstance.getPosY());
 406                 assertEquals(newName, actualComponentInstance.getName());
 407                 assertEquals(newName.toLowerCase(), actualComponentInstance.getNormalizedName());
 408         }
 409
 410         @Test(enabled = false)
 411         public void updateServiceInstanceNameRemoveSpacesFromBiginningAndEnd() throws Exception {
 412                 ComponentInstanceReqDetails serviceInstanceReqDetails = ElementFactory.getComponentResourceInstance(serviceDetails_01);
 413                 RestResponse createServiceInstanceResp = ComponentInstanceRestUtils.createComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 414                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 415                 String newName = "  Abcd   ";
 416                 String expectedNewName = "  Abcd   ";
 417                 serviceInstanceReqDetails.setName(newName);
 418                 RestResponse updateServiceInstanceResponse = ComponentInstanceRestUtils.updateComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 419                 ResourceRestUtils.checkSuccess(updateServiceInstanceResponse);
 420                 String instanceNormalizedName = ResponseParser.getValueFromJsonResponse(updateServiceInstanceResponse.getResponse(), "normalizedName");
 421                 String instanceName = ResponseParser.getValueFromJsonResponse(updateServiceInstanceResponse.getResponse(), "name");
 422                 assertEquals("check Resource Instance normalizedName ", (expectedNewName).toLowerCase(), instanceNormalizedName);
 423                 assertEquals("check Resource Instance Name ", expectedNewName, instanceName);
 424                 // get product and verify that service instanceName is correct
 425                 RestResponse getActualProductResponse = ProductRestUtils.getProduct(productDetails_01.getUniqueId(), sdncPmDetails1.getUserId());
 426                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getActualProductResponse.getResponse(), Product.class);
 427                 ComponentInstance actualComponentInstance = actualProduct.getComponentInstances().get(0);
 428                 assertEquals(expectedNewName, actualComponentInstance.getName());
 429                 assertEquals((expectedNewName).toLowerCase(), actualComponentInstance.getNormalizedName());
 430         }
 431
 432         // pass
 433         @Test
 434         public void updateServiceInstanceNameAllowedCharacters() throws Exception {
 435                 ComponentInstanceReqDetails serviceInstanceReqDetails = ElementFactory.getComponentResourceInstance(serviceDetails_01);
 436                 RestResponse createServiceInstanceResp = ComponentInstanceRestUtils.createComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 437                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 438                 String newName = "qwer-TYUIOP_asd_0987654321.Abcd";
 439                 String ExpectedNormalizName = "qwertyuiopasd0987654321abcd";
 440                 serviceInstanceReqDetails.setName(newName);
 441                 RestResponse updateServiceInstanceResponse = ComponentInstanceRestUtils.updateComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 442                 ResourceRestUtils.checkSuccess(updateServiceInstanceResponse);
 443                 String instanceNormalizedName = ResponseParser.getValueFromJsonResponse(updateServiceInstanceResponse.getResponse(), "normalizedName");
 444                 String instanceName = ResponseParser.getValueFromJsonResponse(updateServiceInstanceResponse.getResponse(), "name");
 445                 assertEquals("check Resource Instance normalizedName ", ExpectedNormalizName, instanceNormalizedName);
 446                 assertEquals("check Resource Instance Name ", newName, instanceName);
 447                 // get product and verify that service instanceName is correct
 448                 RestResponse getActualProductResponse = ProductRestUtils.getProduct(productDetails_01.getUniqueId(), sdncPmDetails1.getUserId());
 449                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getActualProductResponse.getResponse(), Product.class);
 450                 ComponentInstance actualComponentInstance = actualProduct.getComponentInstances().get(0);
 451                 assertEquals(newName, actualComponentInstance.getName());
 452                 assertEquals(ExpectedNormalizName, actualComponentInstance.getNormalizedName());
 453
 454         }
 455
 456         @Test
 457         public void updateInstanceNameInvalidCharacters() throws Exception {
 458                 char invalidChars[] = { '~', '!', '$', '%', '^', '*', '(', ')', '"', '{', '}', '[', ']', '?', '>', '<', '/', '|', '\\', ',' };
 459                 ComponentInstanceReqDetails serviceInstanceReqDetails = ElementFactory.getComponentResourceInstance(serviceDetails_01);
 460                 RestResponse createServiceInstanceResp = ComponentInstanceRestUtils.createComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 461                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 462                 String newName = "Abcd1";
 463                 String updateName;
 464                 for (int i = 0; i < invalidChars.length; i++) {
 465                         updateName = newName + invalidChars[i];
 466                         serviceInstanceReqDetails.setName(updateName);
 467                         RestResponse updateServiceInstanceResponse = ComponentInstanceRestUtils.updateComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 468                         assertEquals("Check response code ", STATUS_CODE_INVALID_CONTENT, updateServiceInstanceResponse.getErrorCode().intValue());
 469                         ArrayList<String> varibales = new ArrayList<String>();
 470                         varibales.add("Service Instance");
 471                         ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_COMPONENT_NAME.name(), varibales, updateServiceInstanceResponse.getResponse());
 472                 }
 473         }
 474
 475         // pass
 476         @Test
 477         public void updateInstanceNameMaxLength() throws Exception {
 478                 ComponentInstanceReqDetails serviceInstanceReqDetails = ElementFactory.getComponentResourceInstance(serviceDetails_01);
 479                 RestResponse createServiceInstanceResp = ComponentInstanceRestUtils.createComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 480                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 481                 String newName = "Qwertyuiop1234567890asdfAhjklzxcvbnmasdfghjkl12345";
 482                 serviceInstanceReqDetails.setName(newName);
 483                 RestResponse updateServiceInstanceResponse = ComponentInstanceRestUtils.updateComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 484                 ResourceRestUtils.checkSuccess(updateServiceInstanceResponse);
 485                 String instanceNormalizedName = ResponseParser.getValueFromJsonResponse(updateServiceInstanceResponse.getResponse(), "normalizedName");
 486                 String instanceName = ResponseParser.getValueFromJsonResponse(updateServiceInstanceResponse.getResponse(), "name");
 487                 assertEquals("check Resource Instance normalizedName ", (newName).toLowerCase(), instanceNormalizedName);
 488                 assertEquals("check Resource Instance Name ", newName, instanceName);
 489                 // get product and verify that service instanceName is correct
 490                 RestResponse getActualProductResponse = ProductRestUtils.getProduct(productDetails_01.getUniqueId(), sdncPmDetails1.getUserId());
 491                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getActualProductResponse.getResponse(), Product.class);
 492                 ComponentInstance actualComponentInstance = actualProduct.getComponentInstances().get(0);
 493                 assertEquals(newName, actualComponentInstance.getName());
 494                 assertEquals((newName).toLowerCase(), actualComponentInstance.getNormalizedName());
 495         }
 496
 497         @Test
 498         public void updateInstanceNameExceedMaxLength() throws Exception {
 499                 ComponentInstanceReqDetails serviceInstanceReqDetails = ElementFactory.getComponentResourceInstance(serviceDetails_01);
 500                 RestResponse createServiceInstanceResp = ComponentInstanceRestUtils.createComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 501                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 502                 String expectedName = ResponseParser.getValueFromJsonResponse(createServiceInstanceResp.getResponse(), "name");
 503                 String expectedNormalizedName = ResponseParser.getValueFromJsonResponse(createServiceInstanceResp.getResponse(), "normalizedName");
 504                 String newName = "Qwertyuiop1234567890asdfAhjklzxcvbnmasdfghjkl123456";
 505                 serviceInstanceReqDetails.setName(newName);
 506                 RestResponse updateServiceInstanceResponse = ComponentInstanceRestUtils.updateComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 507                 assertEquals("Check response code ", STATUS_CODE_COMPONENT_NAME_EXCEEDS_LIMIT, updateServiceInstanceResponse.getErrorCode().intValue());
 508                 ArrayList<String> varibales = new ArrayList<String>();
 509                 varibales.add("Service Instance");
 510                 varibales.add("50");
 511                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_NAME_EXCEEDS_LIMIT.name(), varibales, updateServiceInstanceResponse.getResponse());
 512                 // get product and verify that service instanceName is correct
 513                 RestResponse getActualProductResponse = ProductRestUtils.getProduct(productDetails_01.getUniqueId(), sdncPmDetails1.getUserId());
 514                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getActualProductResponse.getResponse(), Product.class);
 515                 ComponentInstance actualComponentInstance = actualProduct.getComponentInstances().get(0);
 516                 assertEquals(expectedName, actualComponentInstance.getName());
 517                 assertEquals(expectedNormalizedName, actualComponentInstance.getNormalizedName());
 518         }
 519
 520         @Test
 521         public void updateServiceInstanceNameEmpty() throws Exception {
 522                 // see US534663 In case a PS/PM removes the current service instance
 523                 // name then BE has to generate again the "default" service instance
 524                 // name
 525                 ComponentInstanceReqDetails serviceInstanceReqDetails = ElementFactory.getComponentResourceInstance(serviceDetails_01);
 526                 RestResponse createServiceInstanceResp = ComponentInstanceRestUtils.createComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 527                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 528                 String newName = "";
 529                 serviceInstanceReqDetails.setName(newName);
 530                 RestResponse updateServiceInstanceResponse = ComponentInstanceRestUtils.updateComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 531                 ResourceRestUtils.checkSuccess(updateServiceInstanceResponse);
 532                 String instanceNormalizedName = ResponseParser.getValueFromJsonResponse(updateServiceInstanceResponse.getResponse(), "normalizedName");
 533                 String instanceName = ResponseParser.getValueFromJsonResponse(updateServiceInstanceResponse.getResponse(), "name");
 534                 assertEquals("check Resource Instance normalizedName ", (serviceDetails_01.getName() + "2").toLowerCase(), instanceNormalizedName);
 535                 assertEquals("check Resource Instance normalizedName ", (serviceDetails_01.getName() + " 2"), instanceName);
 536                 // get product and verify that service instanceName is correct
 537                 RestResponse getActualProductResponse = ProductRestUtils.getProduct(productDetails_01.getUniqueId(), sdncPmDetails1.getUserId());
 538                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getActualProductResponse.getResponse(), Product.class);
 539                 ComponentInstance actualComponentInstance = actualProduct.getComponentInstances().get(0);
 540                 assertEquals(instanceName, actualComponentInstance.getName());
 541                 assertEquals(instanceNormalizedName, actualComponentInstance.getNormalizedName());
 542         }
 543
 544         // pass
 545         @Test
 546         public void updateServiceInstanceNameNull() throws Exception {
 547                 // see US534663 In case a PS/PM removes the current service instance
 548                 // name then BE has to generate again the "default" service instance
 549                 // name
 550                 ComponentInstanceReqDetails serviceInstanceReqDetails = ElementFactory.getComponentResourceInstance(serviceDetails_01);
 551                 RestResponse createServiceInstanceResp = ComponentInstanceRestUtils.createComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 552                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 553                 String newName = null;
 554                 serviceInstanceReqDetails.setName(newName);
 555                 RestResponse updateServiceInstanceResponse = ComponentInstanceRestUtils.updateComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 556                 ResourceRestUtils.checkSuccess(updateServiceInstanceResponse);
 557                 String instanceNormalizedName = ResponseParser.getValueFromJsonResponse(updateServiceInstanceResponse.getResponse(), "normalizedName");
 558                 String instanceName = ResponseParser.getValueFromJsonResponse(updateServiceInstanceResponse.getResponse(), "name");
 559                 assertEquals("check Resource Instance normalizedName ", (serviceDetails_01.getName() + "2").toLowerCase(), instanceNormalizedName);
 560                 assertEquals("check Resource Instance normalizedName ", (serviceDetails_01.getName() + " 2"), instanceName);
 561                 // get product and verify that service instanceName is correct
 562                 RestResponse getActualProductResponse = ProductRestUtils.getProduct(productDetails_01.getUniqueId(), sdncPmDetails1.getUserId());
 563                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getActualProductResponse.getResponse(), Product.class);
 564                 ComponentInstance actualComponentInstance = actualProduct.getComponentInstances().get(0);
 565                 assertEquals(instanceName, actualComponentInstance.getName());
 566                 assertEquals(instanceNormalizedName, actualComponentInstance.getNormalizedName());
 567         }
 568
 569         @Test
 570         public void updateServiceInstanceCheckedByOtherUser() throws Exception {
 571                 // see US534663 In case a PS/PM removes the current service instance
 572                 // name then BE has to generate again the "default" service instance
 573                 // name
 574                 ComponentInstanceReqDetails serviceInstanceReqDetails = ElementFactory.getComponentResourceInstance(serviceDetails_01);
 575                 RestResponse createServiceInstanceResp = ComponentInstanceRestUtils.createComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 576                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 577                 String newName = "blabla";
 578                 serviceInstanceReqDetails.setName(newName);
 579                 RestResponse updateServiceInstanceResponse = ComponentInstanceRestUtils.updateComponentInstance(serviceInstanceReqDetails, sdncPmDetails2, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 580                 assertEquals("Check response code ", STATUS_CODE_RESTRICTED_OPERATION, updateServiceInstanceResponse.getErrorCode().intValue());
 581                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(), updateServiceInstanceResponse.getResponse());
 582         }
 583
 584         @Test
 585         public void updateServiceInstance_UserIdIsNonAsdcUser() throws Exception {
 586                 ComponentInstanceReqDetails serviceInstanceReqDetails = ElementFactory.getComponentResourceInstance(serviceDetails_01);
 587                 RestResponse createServiceInstanceResp = ComponentInstanceRestUtils.createComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 588                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 589                 String newName = "blabla";
 590                 serviceInstanceReqDetails.setName(newName);
 591                 User nonSdncUserDetails = new User();
 592                 nonSdncUserDetails.setUserId("bt4567");
 593                 RestResponse updateServiceInstanceResponse = ComponentInstanceRestUtils.updateComponentInstance(serviceInstanceReqDetails, nonSdncUserDetails, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 594                 assertEquals("Check response code ", STATUS_CODE_RESTRICTED_OPERATION, updateServiceInstanceResponse.getErrorCode().intValue());
 595                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(), updateServiceInstanceResponse.getResponse());
 596         }
 597
 598         @Test
 599         public void updateServiceInstanceNameToAlreadyExisting() throws Exception {
 600                 ComponentInstanceReqDetails serviceInstanceReqDetails = ElementFactory.getComponentResourceInstance(serviceDetails_01);
 601                 RestResponse createServiceInstanceResp = ComponentInstanceRestUtils.createComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 602                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 603                 String ServiceName1 = ResponseParser.getNameFromResponse(createServiceInstanceResp);
 604                 createServiceInstanceResp = ComponentInstanceRestUtils.createComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 605                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 606                 // Update service instance2 name to service instance1
 607                 serviceInstanceReqDetails.setName(ServiceName1);
 608                 RestResponse updateServiceInstanceResponse = ComponentInstanceRestUtils.updateComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 609                 assertEquals("Check response code ", STATUS_CODE_ALREADY_EXISTS, updateServiceInstanceResponse.getErrorCode().intValue());
 610                 ArrayList<String> varibales = new ArrayList<String>();
 611                 varibales.add("Service Instance");
 612                 varibales.add(ServiceName1);
 613                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_NAME_ALREADY_EXIST.name(), varibales, updateServiceInstanceResponse.getResponse());
 614         }
 615
 616         @Test
 617         public void updateServiceInstanceForNonExistingProduct() throws Exception {
 618                 ComponentInstanceReqDetails serviceInstanceReqDetails = ElementFactory.getComponentResourceInstance(serviceDetails_01);
 619                 RestResponse createServiceInstanceResp = ComponentInstanceRestUtils.createComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 620                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 621                 String newName = "blabla";
 622                 serviceInstanceReqDetails.setName(newName);
 623                 RestResponse updateServiceInstanceResponse = ComponentInstanceRestUtils.updateComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, "blablabla", ComponentTypeEnum.PRODUCT);
 624                 AssertJUnit.assertEquals("Check response code ", STATUS_CODE_NOT_FOUND, updateServiceInstanceResponse.getErrorCode().intValue());
 625                 ArrayList<String> varibales = new ArrayList<String>();
 626                 varibales.add("");
 627                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.PRODUCT_NOT_FOUND.name(), varibales, updateServiceInstanceResponse.getResponse());
 628
 629         }
 630
 631         @Test
 632         public void updateNonExistingServiceInstance() throws Exception {
 633                 ComponentInstanceReqDetails serviceInstanceReqDetails = ElementFactory.getComponentResourceInstance(serviceDetails_01);
 634                 RestResponse createServiceInstanceResp = ComponentInstanceRestUtils.createComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 635                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 636                 String newName = "blabla";
 637                 serviceInstanceReqDetails.setName(newName);
 638                 serviceInstanceReqDetails.setUniqueId("11111111");
 639                 RestResponse updateServiceInstanceResponse = ComponentInstanceRestUtils.updateComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 640                 ArrayList<String> varibales = new ArrayList<String>();
 641                 varibales.add(newName);
 642                 varibales.add("service instance");
 643                 AssertJUnit.assertEquals("Check response code ", STATUS_CODE_NOT_FOUND, updateServiceInstanceResponse.getErrorCode().intValue());
 644                 // need to change ActionStatus.RESOURCE_INSTANCE_NOT_FOUND.name() to
 645                 // ActionStatus.SERVICE_INSTANCE_NOT_FOUND.name()
 646                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_INSTANCE_NOT_FOUND.name(), varibales, updateServiceInstanceResponse.getResponse());
 647         }
 648
 649         @Test
 650         public void updateServiceInstanceLocation() throws Exception {
 651                 ComponentInstanceReqDetails serviceInstanceReqDetails = ElementFactory.getComponentResourceInstance(serviceDetails_01);
 652                 RestResponse createServiceInstanceResp = ComponentInstanceRestUtils.createComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 653                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 654                 serviceInstanceReqDetails.setPosX("50");
 655                 serviceInstanceReqDetails.setPosY("100");
 656                 RestResponse updateServiceInstanceResponse = ComponentInstanceRestUtils.updateComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 657                 ResourceRestUtils.checkSuccess(updateServiceInstanceResponse);
 658                 // get product and verify that service instanceName is correct
 659                 RestResponse getActualProductResponse = ProductRestUtils.getProduct(productDetails_01.getUniqueId(), sdncPmDetails1.getUserId());
 660                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getActualProductResponse.getResponse(), Product.class);
 661                 ComponentInstance actualComponentInstance = actualProduct.getComponentInstances().get(0);
 662                 assertEquals(serviceInstanceReqDetails.getPosX(), actualComponentInstance.getPosX());
 663                 assertEquals(serviceInstanceReqDetails.getPosY(), actualComponentInstance.getPosY());
 664         }
 665
 666         @Test
 667         public void updateServiceInstanceToNonExistingLocation() throws Exception {
 668                 ComponentInstanceReqDetails serviceInstanceReqDetails = ElementFactory.getComponentResourceInstance(serviceDetails_01);
 669                 RestResponse createServiceInstanceResp = ComponentInstanceRestUtils.createComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 670                 String nameFromResponse = ResponseParser.getNameFromResponse(createServiceInstanceResp);
 671                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 672                 serviceInstanceReqDetails.setPosX("-50");
 673                 serviceInstanceReqDetails.setPosY("-100");
 674                 serviceInstanceReqDetails.setName(nameFromResponse);
 675                 RestResponse updateServiceInstanceResponse = ComponentInstanceRestUtils.updateComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 676                 ResourceRestUtils.checkSuccess(updateServiceInstanceResponse);
 677                 // get product and verify that service instanceName is correct
 678                 RestResponse getActualProductResponse = ProductRestUtils.getProduct(productDetails_01.getUniqueId(), sdncPmDetails1.getUserId());
 679                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getActualProductResponse.getResponse(), Product.class);
 680                 ComponentInstance actualComponentInstance = actualProduct.getComponentInstances().get(0);
 681                 assertEquals(serviceInstanceReqDetails.getPosX(), actualComponentInstance.getPosX());
 682                 assertEquals(serviceInstanceReqDetails.getPosY(), actualComponentInstance.getPosY());
 683                 assertEquals(nameFromResponse, actualComponentInstance.getName());
 684         }
 685
 686         @Test
 687         public void updateServiceInstanceLocationNameIsEmpty() throws Exception {
 688                 String expectedServiceInstanceName = serviceDetails_01.getName() + " 2";
 689                 String expectedServiceInstancenormalizedName = serviceDetails_01.getName() + "2";
 690                 ComponentInstanceReqDetails serviceInstanceReqDetails = ElementFactory.getComponentResourceInstance(serviceDetails_01);
 691                 RestResponse createServiceInstanceResp = ComponentInstanceRestUtils.createComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 692                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 693                 serviceInstanceReqDetails.setPosX("100");
 694                 serviceInstanceReqDetails.setPosY("200");
 695                 serviceInstanceReqDetails.setName("");
 696                 RestResponse updateServiceInstanceResponse = ComponentInstanceRestUtils.updateComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 697                 ResourceRestUtils.checkSuccess(updateServiceInstanceResponse);
 698                 String nameFromResponse = ResponseParser.getNameFromResponse(updateServiceInstanceResponse);
 699                 String postX = ResponseParser.getValueFromJsonResponse(updateServiceInstanceResponse.getResponse(), "posX");
 700                 String postY = ResponseParser.getValueFromJsonResponse(updateServiceInstanceResponse.getResponse(), "posY");
 701                 assertEquals(nameFromResponse, expectedServiceInstanceName);
 702                 assertEquals(postX, "100");
 703                 assertEquals(postY, "200");
 704                 // get product and verify that service instanceName is correct
 705                 RestResponse getActualProductResponse = ProductRestUtils.getProduct(productDetails_01.getUniqueId(), sdncPmDetails1.getUserId());
 706                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getActualProductResponse.getResponse(), Product.class);
 707                 ComponentInstance actualComponentInstance = actualProduct.getComponentInstances().get(0);
 708                 assertEquals(serviceInstanceReqDetails.getPosX(), actualComponentInstance.getPosX());
 709                 assertEquals(serviceInstanceReqDetails.getPosY(), actualComponentInstance.getPosY());
 710                 assertEquals(nameFromResponse, actualComponentInstance.getName());
 711                 assertEquals(expectedServiceInstancenormalizedName.toLowerCase(), actualComponentInstance.getNormalizedName());
 712         }
 713
 714         // pass
 715         @Test
 716         public void updateServiceInstanceNameToProductName() throws Exception {
 717                 ComponentInstanceReqDetails serviceInstanceReqDetails = ElementFactory.getComponentResourceInstance(serviceDetails_01);
 718                 RestResponse createServiceInstanceResp = ComponentInstanceRestUtils.createComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 719                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 720                 // ComponentInstance componentInstance =
 721                 // ResponseParser.parseToObjectUsingMapper(createServiceInstanceResp.getResponse(),
 722                 // ComponentInstance.class);
 723                 // addCompInstReqCapToExpected(componentInstance,
 724                 // ComponentTypeEnum.PRODUCT);
 725                 serviceInstanceReqDetails.setName(productDetails_01.getName());
 726                 RestResponse updateServiceInstanceResponse = ComponentInstanceRestUtils.updateComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
 727                 ResourceRestUtils.checkSuccess(updateServiceInstanceResponse);
 728                 String instanceNormalizedName = ResponseParser.getValueFromJsonResponse(updateServiceInstanceResponse.getResponse(), "normalizedName");
 729                 String instanceName = ResponseParser.getValueFromJsonResponse(updateServiceInstanceResponse.getResponse(), "name");
 730                 assertEquals("check Resource Instance normalizedName ", (serviceInstanceReqDetails.getName()).toLowerCase(), instanceNormalizedName);
 731                 assertEquals("check Resource Instance Name ", serviceInstanceReqDetails.getName(), instanceName);
 732                 // get product and verify that service instanceName is correct
 733                 RestResponse getActualProductResponse = ProductRestUtils.getProduct(productDetails_01.getUniqueId(), sdncPmDetails1.getUserId());
 734                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getActualProductResponse.getResponse(), Product.class);
 735                 ComponentInstance actualComponentInstance = actualProduct.getComponentInstances().get(0);
 736                 assertEquals(serviceInstanceReqDetails.getName(), actualComponentInstance.getName());
 737                 assertEquals((serviceInstanceReqDetails.getName()).toLowerCase(), actualComponentInstance.getNormalizedName());
 738         }
 739
 740         //// Delete Service Instance
 741
 742         @Test
 743         public void deleteAllServiceInstanceFromProduct() throws Exception {
 744                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 745                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 746                 String serviceInstanceUniqueId = ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
 747                 getComponentAndValidateRIs(productDetails_01, 1, 0);
 748                 RestResponse deleteServiceInstanceResp = deleteServiceInstance(serviceInstanceUniqueId, productDetails_01, sdncPmDetails1);
 749                 assertTrue(deleteServiceInstanceResp.getErrorCode() == STATUS_CODE_SUCCESS_DELETE);
 750                 getComponentAndValidateRIs(productDetails_01, 0, 0);
 751         }
 752
 753         @Test
 754         public void deleteServiceWhileServiceInstanceExistInProduct() throws Exception {
 755                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 756                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 757                 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
 758                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 759                 String serviceInstanceUniqueIdFromResponse = ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
 760                 getComponentAndValidateRIs(productDetails_01, 2, 0);
 761                 // Delete service while service instance of it exist in product
 762                 RestResponse deleteServiceResponse = ServiceRestUtils.deleteServiceById(serviceDetails_01.getUniqueId(), sdncDesignerDetails.getUserId());
 763                 assertTrue(deleteServiceResponse.getErrorCode() == STATUS_CODE_SUCCESS_DELETE);
 764                 // Get product and verify that service instance still exists
 765                 RestResponse getActualProductResponse = ProductRestUtils.getProduct(productDetails_01.getUniqueId(), sdncPmDetails1.getUserId());
 766                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getActualProductResponse.getResponse(), Product.class);
 767                 // ComponentInstance actualComponentInstance =
 768                 // actualProduct.getComponentInstances().get(0);
 769                 // assertTrue(serviceInstanceUniqueIdFromResponse ==
 770                 // actualComponentInstance.getUniqueId());
 771                 getComponentAndValidateRIs(productDetails_01, 2, 0);
 772         }
 773
 774         // pass
 775         @Test
 776         public void deleteServiceInstanceByPm() throws Exception {
 777                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 778                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 779                 String serviceInstanceUniqueId = ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
 780                 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 781                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 782                 getComponentAndValidateRIs(productDetails_01, 2, 0);
 783                 RestResponse deleteServiceInstanceResp = deleteServiceInstance(serviceInstanceUniqueId, productDetails_01, sdncPmDetails1);
 784                 assertTrue(deleteServiceInstanceResp.getErrorCode() == STATUS_CODE_SUCCESS_DELETE);
 785                 getComponentAndValidateRIs(productDetails_01, 1, 0);
 786         }
 787
 788         @Test
 789         public void deleteServiceInstanceByPmCreatedByPm() throws Exception {
 790                 RestResponse restResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1, LifeCycleStatesEnum.CHECKIN);
 791                 ResourceRestUtils.checkSuccess(restResponse);
 792                 restResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1, LifeCycleStatesEnum.CHECKOUT);
 793                 ResourceRestUtils.checkSuccess(restResponse);
 794                 productDetails_01.setUniqueId(ResponseParser.getUniqueIdFromResponse(restResponse));
 795                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 796                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 797                 String serviceInstanceUniqueId = ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
 798                 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 799                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 800                 getComponentAndValidateRIs(productDetails_01, 2, 0);
 801                 RestResponse deleteServiceInstanceResp = deleteServiceInstance(serviceInstanceUniqueId, productDetails_01, sdncPmDetails1);
 802                 assertTrue(deleteServiceInstanceResp.getErrorCode() == STATUS_CODE_SUCCESS_DELETE);
 803                 getComponentAndValidateRIs(productDetails_01, 1, 0);
 804         }
 805
 806         @Test
 807         public void deleteServiceInstanceByPmWhichIsCheckedOutByAnotherPm() throws Exception {
 808                 RestResponse restResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1, LifeCycleStatesEnum.CHECKIN);
 809                 ResourceRestUtils.checkSuccess(restResponse);
 810                 restResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1, LifeCycleStatesEnum.CHECKOUT);
 811                 ResourceRestUtils.checkSuccess(restResponse);
 812                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 813                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 814                 String serviceInstanceUniqueId = ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
 815                 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 816                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 817                 getComponentAndValidateRIs(productDetails_01, 2, 0);
 818                 RestResponse deleteServiceInstanceResp = deleteServiceInstance(serviceInstanceUniqueId, productDetails_01, sdncPmDetails2);
 819                 assertTrue(deleteServiceInstanceResp.getErrorCode() == STATUS_CODE_RESTRICTED_OPERATION);
 820                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(), deleteServiceInstanceResp.getResponse());
 821                 getComponentAndValidateRIs(productDetails_01, 2, 0);
 822         }
 823
 824         // DE190189
 825         @Test
 826         public void deleteServiceInstanceByPmCreatedByPs() throws Exception {
 827                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 828                 String productOldUniqueId = productDetails_01.getUniqueId();
 829                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 830                 getComponentAndValidateRIs(productDetails_01, 1, 0);
 831                 RestResponse restResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1, LifeCycleStatesEnum.CHECKIN);
 832                 ResourceRestUtils.checkSuccess(restResponse);
 833                 restResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1, LifeCycleStatesEnum.CHECKOUT);
 834                 ResourceRestUtils.checkSuccess(restResponse);
 835                 String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(restResponse);
 836                 updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
 837                 // get product and get service instance new uniquId
 838                 RestResponse getActualProductResponse = ProductRestUtils.getProduct(productDetails_01.getUniqueId(), sdncPmDetails1.getUserId());
 839                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getActualProductResponse.getResponse(), Product.class);
 840                 ComponentInstance actualComponentInstance = actualProduct.getComponentInstances().get(0);
 841                 String serviceInstanceUniqueId = actualComponentInstance.getUniqueId();
 842                 RestResponse deleteServiceInstanceResp = deleteServiceInstance(serviceInstanceUniqueId, productDetails_01, sdncPmDetails1);
 843                 assertTrue(deleteServiceInstanceResp.getErrorCode() == STATUS_CODE_SUCCESS_DELETE);
 844                 getComponentAndValidateRIs(productDetails_01, 0, 0);
 845         }
 846
 847         // DE190189
 848         @Test
 849         public void deleteServiceInstanceByAdminCreatedByPs() throws Exception {
 850                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 851                 String productOldUniqueId = productDetails_01.getUniqueId();
 852                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 853                 getComponentAndValidateRIs(productDetails_01, 1, 0);
 854                 RestResponse restResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1, LifeCycleStatesEnum.CHECKIN);
 855                 ResourceRestUtils.checkSuccess(restResponse);
 856                 restResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncAdminDetails, LifeCycleStatesEnum.CHECKOUT);
 857                 ResourceRestUtils.checkSuccess(restResponse);
 858                 String productNewUniqueId = ResponseParser.getUniqueIdFromResponse(restResponse);
 859                 updateExpectedReqCapAfterChangeLifecycleState(productOldUniqueId, productNewUniqueId);
 860                 // get product and get service instance new uniquId
 861                 RestResponse getActualProductResponse = ProductRestUtils.getProduct(productDetails_01.getUniqueId(), sdncAdminDetails.getUserId());
 862                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getActualProductResponse.getResponse(), Product.class);
 863                 ComponentInstance actualComponentInstance = actualProduct.getComponentInstances().get(0);
 864                 String serviceInstanceUniqueId = actualComponentInstance.getUniqueId();
 865                 RestResponse deleteServiceInstanceResp = deleteServiceInstance(serviceInstanceUniqueId, productDetails_01, sdncAdminDetails);
 866                 assertTrue(deleteServiceInstanceResp.getErrorCode() == STATUS_CODE_SUCCESS_DELETE);
 867                 getComponentAndValidateRIs(productDetails_01, 0, 0);
 868         }
 869
 870         @Test
 871         public void createAndDeleteServiceInstanceByAdmin() throws Exception {
 872                 RestResponse restResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1, LifeCycleStatesEnum.CHECKIN);
 873                 ResourceRestUtils.checkSuccess(restResponse);
 874                 restResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncAdminDetails, LifeCycleStatesEnum.CHECKOUT);
 875                 ResourceRestUtils.checkSuccess(restResponse);
 876                 // productDetails_01.setUniqueId(ResponseParser.getUniqueIdFromResponse(restResponse));
 877                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncAdminDetails);
 878                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 879                 String serviceInstanceUniqueId = ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
 880                 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncAdminDetails);
 881                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 882                 getComponentAndValidateRIs(productDetails_01, 2, 0);
 883                 RestResponse deleteServiceInstanceResp = deleteServiceInstance(serviceInstanceUniqueId, productDetails_01, sdncAdminDetails);
 884                 assertTrue(deleteServiceInstanceResp.getErrorCode() == STATUS_CODE_SUCCESS_DELETE);
 885                 getComponentAndValidateRIs(productDetails_01, 1, 0);
 886         }
 887
 888         @Test
 889         public void deleteServiceInstanceFromNonCheckOutProduct() throws Exception {
 890                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 891                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 892                 String serviceInstanceUniqueId = ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
 893                 getComponentAndValidateRIs(productDetails_01, 1, 0);
 894                 RestResponse restResponse = LifecycleRestUtils.changeProductState(productDetails_01, sdncPmDetails1, LifeCycleStatesEnum.CHECKIN);
 895                 ResourceRestUtils.checkSuccess(restResponse);
 896                 RestResponse deleteServiceInstanceResp = deleteServiceInstance(serviceInstanceUniqueId, productDetails_01, sdncPmDetails1);
 897                 assertTrue(deleteServiceInstanceResp.getErrorCode() == STATUS_CODE_RESTRICTED_OPERATION);
 898                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(), deleteServiceInstanceResp.getResponse());
 899                 getComponentAndValidateRIs(productDetails_01, 1, 0);
 900         }
 901
 902         @Test
 903         public void deleteServiceInstanceByDesigner() throws Exception {
 904                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 905                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 906                 String serviceInstanceUniqueId = ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
 907                 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 908                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 909                 getComponentAndValidateRIs(productDetails_01, 2, 0);
 910                 RestResponse deleteServiceInstanceResp = deleteServiceInstance(serviceInstanceUniqueId, productDetails_01, sdncDesignerDetails);
 911                 assertTrue(deleteServiceInstanceResp.getErrorCode() == STATUS_CODE_RESTRICTED_OPERATION);
 912                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(), deleteServiceInstanceResp.getResponse());
 913                 getComponentAndValidateRIs(productDetails_01, 2, 0);
 914         }
 915
 916         @Test
 917         public void deleteServiceInstanceByTester() throws Exception {
 918                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 919                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 920                 String serviceInstanceUniqueId = ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
 921                 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 922                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 923                 getComponentAndValidateRIs(productDetails_01, 2, 0);
 924                 RestResponse deleteServiceInstanceResp = deleteServiceInstance(serviceInstanceUniqueId, productDetails_01, sdncTesterDetails);
 925                 assertTrue(deleteServiceInstanceResp.getErrorCode() == STATUS_CODE_RESTRICTED_OPERATION);
 926                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(), deleteServiceInstanceResp.getResponse());
 927                 getComponentAndValidateRIs(productDetails_01, 2, 0);
 928         }
 929
 930         @Test
 931         public void deleteServiceInstanceByPsWhichIsCheckedOutByAnotherPs() throws Exception {
 932                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 933                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 934                 String serviceInstanceUniqueId = ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
 935                 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 936                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 937                 getComponentAndValidateRIs(productDetails_01, 2, 0);
 938                 RestResponse deleteServiceInstanceResp = deleteServiceInstance(serviceInstanceUniqueId, productDetails_01, sdncPsDetails2);
 939                 assertTrue(deleteServiceInstanceResp.getErrorCode() == STATUS_CODE_RESTRICTED_OPERATION);
 940                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(), deleteServiceInstanceResp.getResponse());
 941                 getComponentAndValidateRIs(productDetails_01, 2, 0);
 942         }
 943
 944         // pass
 945         @Test
 946         public void deleteServiceInstanceByNonAsdcUser() throws Exception {
 947                 User nonExistingSdncUser = ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1);
 948                 ;
 949                 nonExistingSdncUser.setUserId("bt1234");
 950                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 951                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 952                 String serviceInstanceUniqueId = ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
 953                 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 954                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 955                 getComponentAndValidateRIs(productDetails_01, 2, 0);
 956                 RestResponse deleteServiceInstanceResp = deleteServiceInstance(serviceInstanceUniqueId, productDetails_01, nonExistingSdncUser);
 957                 assertTrue(deleteServiceInstanceResp.getErrorCode() == STATUS_CODE_RESTRICTED_OPERATION);
 958                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(), deleteServiceInstanceResp.getResponse());
 959                 getComponentAndValidateRIs(productDetails_01, 2, 0);
 960         }
 961
 962         @Test
 963         public void deleteServiceInstanceFromNonExistingProduct() throws Exception {
 964                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 965                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 966                 String serviceInstanceUniqueId = ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
 967                 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 968                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 969                 getComponentAndValidateRIs(productDetails_01, 2, 0);
 970                 RestResponse deleteResourceInstanceResponse = ComponentInstanceRestUtils.deleteComponentInstance(sdncPmDetails1, "1234567890", serviceInstanceUniqueId, ComponentTypeEnum.PRODUCT);
 971                 assertTrue(deleteResourceInstanceResponse.getErrorCode() == STATUS_CODE_NOT_FOUND);
 972                 ArrayList<String> varibales = new ArrayList<String>();
 973                 varibales.add("");
 974                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.PRODUCT_NOT_FOUND.name(), varibales, deleteResourceInstanceResponse.getResponse());
 975                 getComponentAndValidateRIs(productDetails_01, 2, 0);
 976         }
 977
 978         @Test
 979         public void deleteNonExistingServiceInstanceFromProduct() throws Exception {
 980                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 981                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 982                 // String serviceInstanceUniqueId =
 983                 // ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
 984                 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 985                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 986                 getComponentAndValidateRIs(productDetails_01, 2, 0);
 987                 RestResponse deleteResourceInstanceResponse = ComponentInstanceRestUtils.deleteComponentInstance(sdncPmDetails1, productDetails_01.getUniqueId(), "1234567890123456unExistingServiceInstance", ComponentTypeEnum.PRODUCT);
 988                 assertTrue(deleteResourceInstanceResponse.getErrorCode() == STATUS_CODE_NOT_FOUND);
 989                 ArrayList<String> varibales = new ArrayList<String>();
 990                 varibales.add("1234567890123456unExistingServiceInstance");
 991                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.PRODUCT_NOT_FOUND.name(), varibales, deleteResourceInstanceResponse.getResponse());
 992                 getComponentAndValidateRIs(productDetails_01, 2, 0);
 993         }
 994
 995         @Test
 996         public void deleteServiceInstanceFromNonSupportedComponentType() throws Exception {
 997                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
 998                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
 999                 String serviceInstanceUniqueId = ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
1000                 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
1001                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1002                 getComponentAndValidateRIs(productDetails_01, 2, 0);
1003                 RestResponse deleteResourceInstanceResponse = ComponentInstanceRestUtils.deleteComponentInstance(sdncPmDetails1, productDetails_01.getUniqueId(), serviceInstanceUniqueId, ComponentTypeEnum.RESOURCE_INSTANCE);
1004                 assertTrue(deleteResourceInstanceResponse.getErrorCode() == STATUS_CODE_UNSUPPORTED_ERROR);
1005                 ArrayList<String> varibales = new ArrayList<String>();
1006                 varibales.add("null");
1007                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.UNSUPPORTED_ERROR.name(), varibales, deleteResourceInstanceResponse.getResponse());
1008                 getComponentAndValidateRIs(productDetails_01, 2, 0);
1009         }
1010
1011         @Test
1012         public void deleteServiceInstanceComponentTypeIsNotProduct() throws Exception {
1013                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
1014                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1015                 String serviceInstanceUniqueId = ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
1016                 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
1017                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1018                 getComponentAndValidateRIs(productDetails_01, 2, 0);
1019                 RestResponse deleteResourceInstanceResponse = ComponentInstanceRestUtils.deleteComponentInstance(sdncPmDetails1, productDetails_01.getUniqueId(), serviceInstanceUniqueId, ComponentTypeEnum.SERVICE);
1020                 assertTrue(deleteResourceInstanceResponse.getErrorCode() == STATUS_CODE_NOT_FOUND);
1021                 ArrayList<String> varibales = new ArrayList<String>();
1022                 varibales.add("");
1023                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.SERVICE_NOT_FOUND.name(), varibales, deleteResourceInstanceResponse.getResponse());
1024                 getComponentAndValidateRIs(productDetails_01, 2, 0);
1025         }
1026
1027         @Test
1028         public void deleteServiceInstanceUserIdIsEmpty() throws Exception {
1029                 User nonSdncDetails = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
1030                 nonSdncDetails.setUserId("");
1031                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
1032                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1033                 String serviceInstanceUniqueId = ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
1034                 getComponentAndValidateRIs(productDetails_01, 1, 0);
1035                 RestResponse deleteServiceInstanceResp = deleteServiceInstance(serviceInstanceUniqueId, productDetails_01, nonSdncDetails);
1036                 assertTrue(deleteServiceInstanceResp.getErrorCode() == STATUS_CODE_MISSING_INFORMATION);
1037                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_INFORMATION.name(), new ArrayList<String>(), deleteServiceInstanceResp.getResponse());
1038                 getComponentAndValidateRIs(productDetails_01, 1, 0);
1039         }
1040
1041         @Test
1042         public void deleteCertifiedServiceInstance() throws Exception {
1043                 changeServiceStateToCertified(serviceDetails_01);
1044                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
1045                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1046                 String serviceInstanceUniqueId = ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
1047                 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
1048                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1049                 getComponentAndValidateRIs(productDetails_01, 2, 0);
1050                 RestResponse deleteServiceInstanceResp = deleteServiceInstance(serviceInstanceUniqueId, productDetails_01, sdncPmDetails1);
1051                 assertTrue(deleteServiceInstanceResp.getErrorCode() == STATUS_CODE_SUCCESS_DELETE);
1052                 getComponentAndValidateRIs(productDetails_01, 1, 0);
1053         }
1054
1055         ////////////////////////////////////
1056
1057         private void certifyVf(ResourceReqDetails resource) throws Exception {
1058                 RestResponse createAtomicResourceInstance = createAtomicInstanceForVFDuringSetup(resource, resourceDetailsCP_01, sdncDesignerDetails);
1059                 ResourceRestUtils.checkCreateResponse(createAtomicResourceInstance);
1060                 String cpCompInstId = ResponseParser.getUniqueIdFromResponse(createAtomicResourceInstance);
1061
1062                 createAtomicResourceInstance = createAtomicInstanceForVFDuringSetup(resource, resourceDetailsVFC_02, sdncDesignerDetails);
1063                 ResourceRestUtils.checkCreateResponse(createAtomicResourceInstance);
1064                 String computeCompInstId = ResponseParser.getUniqueIdFromResponse(createAtomicResourceInstance);
1065
1066                 createAtomicResourceInstance = createAtomicInstanceForVFDuringSetup(resource, resourceDetailsVL_01, sdncDesignerDetails);
1067                 ResourceRestUtils.checkCreateResponse(createAtomicResourceInstance);
1068                 String vlCompInstId = ResponseParser.getUniqueIdFromResponse(createAtomicResourceInstance);
1069
1070                 // Fixing Vl/Cp req/cap
1071                 ComponentTypeEnum containerCompType = ComponentTypeEnum.RESOURCE;
1072                 User user = sdncDesignerDetails;
1073                 fulfillCpRequirement(resource, cpCompInstId, computeCompInstId, computeCompInstId, user, containerCompType);
1074                 consumeVlCapability(resource, cpCompInstId, vlCompInstId, cpCompInstId, user, containerCompType);
1075
1076                 RestResponse response = ArtifactRestUtils.addInformationalArtifactToResource(heatArtifactDetails, sdncDesignerDetails, resource.getUniqueId());
1077                 ResourceRestUtils.checkSuccess(response);
1078                 RestResponse changeResourceStateToCertified = changeResourceStateToCertified(resource);
1079                 ResourceRestUtils.checkSuccess(changeResourceStateToCertified);
1080         }
1081
1082         private RestResponse changeResourceStateToCertified(ResourceReqDetails resourceDetails) throws Exception {
1083                 RestResponse restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, sdncDesignerDetails, LifeCycleStatesEnum.CHECKIN);
1084                 ResourceRestUtils.checkSuccess(restResponse);
1085                 restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, sdncDesignerDetails, LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1086                 if (restResponse.getErrorCode() == 200) {
1087                         restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, sdncTesterDetails, LifeCycleStatesEnum.STARTCERTIFICATION);
1088                 } else
1089                         return restResponse;
1090                 if (restResponse.getErrorCode() == 200) {
1091                         restResponse = LifecycleRestUtils.changeResourceState(resourceDetails, sdncTesterDetails, LifeCycleStatesEnum.CERTIFY);
1092                         if (restResponse.getErrorCode() == 200) {
1093                                 String newVersion = ResponseParser.getVersionFromResponse(restResponse);
1094                                 resourceDetails.setVersion(newVersion);
1095                                 resourceDetails.setLifecycleState(LifecycleStateEnum.CERTIFIED);
1096                                 resourceDetails.setLastUpdaterUserId(sdncTesterDetails.getUserId());
1097                                 resourceDetails.setLastUpdaterFullName(sdncTesterDetails.getFullName());
1098                                 String uniqueIdFromRresponse = ResponseParser.getValueFromJsonResponse(restResponse.getResponse(), "uniqueId");
1099                                 resourceDetails.setUniqueId(uniqueIdFromRresponse);
1100                         }
1101                 }
1102                 return restResponse;
1103         }
1104
1105         private RestResponse changeServiceStateToCertified(ServiceReqDetails serviceDetails) throws Exception {
1106                 /*
1107                  * RestResponse restResponse = LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, LifeCycleStatesEnum.CHECKIN); ResourceRestUtils.checkSuccess(restResponse);
1108                  */
1109                 RestResponse restResponse = LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1110                 if (restResponse.getErrorCode() == 200) {
1111                         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails, sdncTesterDetails, LifeCycleStatesEnum.STARTCERTIFICATION);
1112                 } else
1113                         return restResponse;
1114                 if (restResponse.getErrorCode() == 200) {
1115                         restResponse = LifecycleRestUtils.changeServiceState(serviceDetails, sdncTesterDetails, LifeCycleStatesEnum.CERTIFY);
1116                         if (restResponse.getErrorCode() == 200) {
1117                                 serviceDetails.setVersion("1.0");
1118                                 serviceDetails.setLifecycleState(LifecycleStateEnum.CERTIFIED);
1119                                 serviceDetails.setLastUpdaterUserId(sdncTesterDetails.getUserId());
1120                                 serviceDetails.setLastUpdaterFullName(sdncTesterDetails.getFullName());
1121                                 String uniqueIdFromRresponse = ResponseParser.getValueFromJsonResponse(restResponse.getResponse(), "uniqueId");
1122                                 serviceDetails.setUniqueId(uniqueIdFromRresponse);
1123                         }
1124                 }
1125                 return restResponse;
1126         }
1127
1128         @Test
1129         public void deleteServiceInstanceTest() throws Exception {
1130                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
1131                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1132                 getComponentAndValidateRIs(productDetails_01, 1, 0);
1133                 String compInstId = ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
1134
1135                 createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_02, sdncPmDetails1);
1136                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1137                 getComponentAndValidateRIs(productDetails_01, 2, 0);
1138                 String compInstId2 = ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
1139
1140                 RestResponse deleteServiceInstanceResp = deleteServiceInstance(compInstId, productDetails_01, sdncPmDetails1);
1141                 ResourceRestUtils.checkDeleteResponse(deleteServiceInstanceResp);
1142                 getComponentAndValidateRIs(productDetails_01, 1, 0);
1143
1144                 deleteServiceInstanceResp = deleteServiceInstance(compInstId2, productDetails_01, sdncPmDetails1);
1145                 ResourceRestUtils.checkDeleteResponse(deleteServiceInstanceResp);
1146                 getComponentAndValidateRIs(productDetails_01, 0, 0);
1147         }
1148
1149         @Test
1150         public void returnedServiceInstanceTypeAttributeTest() throws Exception {
1151                 String expectedServiceType = ComponentTypeEnum.SERVICE.getValue().toUpperCase();
1152
1153                 RestResponse createServiceInstanceResp = createServiceInstance(productDetails_01, serviceDetails_01, sdncPmDetails1);
1154                 ResourceRestUtils.checkCreateResponse(createServiceInstanceResp);
1155                 String serviceUniqueIdFromResponse = ResponseParser.getUniqueIdFromResponse(createServiceInstanceResp);
1156                 ComponentInstanceRestUtils.checkComponentInstanceType(createServiceInstanceResp, expectedServiceType);
1157
1158                 RestResponse getProductResp = ProductRestUtils.getProduct(productDetails_01.getUniqueId(), sdncPsDetails1.getUserId());
1159                 ProductRestUtils.checkSuccess(getProductResp);
1160                 Product productObject = ResponseParser.parseToObjectUsingMapper(getProductResp.getResponse(), Product.class);
1161                 List<ComponentInstance> productComponentInstances = productObject.getComponentInstances();
1162                 for (ComponentInstance comp : productComponentInstances) {
1163                         String actualOriginType = comp.getOriginType().getValue().toUpperCase();
1164                         assertTrue(expectedServiceType.equals(actualOriginType));
1165                 }
1166
1167                 ComponentInstanceReqDetails serviceInstanceReqDetails = ElementFactory.getComponentResourceInstance(serviceDetails_02);
1168                 serviceInstanceReqDetails.setUniqueId(serviceUniqueIdFromResponse);
1169                 serviceInstanceReqDetails.setComponentUid(serviceDetails_01.getUniqueId());
1170                 RestResponse updateResourceInstance = ComponentInstanceRestUtils.updateComponentInstance(serviceInstanceReqDetails, sdncPmDetails1, productDetails_01.getUniqueId(), ComponentTypeEnum.PRODUCT);
1171                 ComponentInstanceRestUtils.checkSuccess(updateResourceInstance);
1172                 ComponentInstanceRestUtils.checkComponentInstanceType(updateResourceInstance, expectedServiceType);
1173
1174         }
1175 }