test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/product/ProductCrudTest.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.testng.AssertJUnit.assertEquals;
  24 import static org.testng.AssertJUnit.assertNotNull;
  25
  26 import java.io.IOException;
  27 import java.util.ArrayList;
  28 import java.util.Arrays;
  29 import java.util.Iterator;
  30 import java.util.List;
  31
  32 import org.junit.Rule;
  33 import org.junit.rules.TestName;
  34 import org.openecomp.sdc.be.dao.api.ActionStatus;
  35 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  36 import org.openecomp.sdc.be.model.Product;
  37 import org.openecomp.sdc.be.model.Resource;
  38 import org.openecomp.sdc.be.model.User;
  39 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  40 import org.openecomp.sdc.ci.tests.api.Urls;
  41 import org.openecomp.sdc.ci.tests.datatypes.ProductReqDetails;
  42 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  43 import org.openecomp.sdc.ci.tests.datatypes.ResourceRespJavaObject;
  44 import org.openecomp.sdc.ci.tests.datatypes.enums.LifeCycleStatesEnum;
  45 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  46 import org.openecomp.sdc.ci.tests.datatypes.expected.ExpectedProductAudit;
  47 import org.openecomp.sdc.ci.tests.datatypes.http.HttpHeaderEnum;
  48 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  49 import org.openecomp.sdc.ci.tests.utils.general.Convertor;
  50 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  51 import org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils;
  52 import org.openecomp.sdc.ci.tests.utils.rest.CatalogRestUtils;
  53 import org.openecomp.sdc.ci.tests.utils.rest.LifecycleRestUtils;
  54 import org.openecomp.sdc.ci.tests.utils.rest.ProductRestUtils;
  55 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils;
  56 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  57 import org.openecomp.sdc.ci.tests.utils.rest.ServiceRestUtils;
  58 import org.openecomp.sdc.ci.tests.utils.validation.AuditValidationUtils;
  59 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  60 import org.openecomp.sdc.ci.tests.utils.validation.ProductValidationUtils;
  61 import org.openecomp.sdc.ci.tests.utils.validation.ResourceValidationUtils;
  62 import org.openecomp.sdc.common.api.Constants;
  63 import org.slf4j.Logger;
  64 import org.slf4j.LoggerFactory;
  65 import org.testng.annotations.Test;
  66
  67 import com.google.gson.JsonArray;
  68 import com.google.gson.JsonElement;
  69 import com.google.gson.JsonObject;
  70 import com.google.gson.JsonParser;
  71
  72 public class ProductCrudTest extends ProductBaseTest {
  73         private static Logger log = LoggerFactory.getLogger(ProductCrudTest.class.getName());
  74         @Rule
  75         public static TestName name = new TestName();
  76
  77         public static String INITIAL_PRODUCT_VERSION = "0.1";
  78         public static String CREATE_AUDIT_ACTION = "Create";
  79         public static String UPDATE_AUDIT_ACTION = "Update";
  80         public static String COMPONENT_TYPE = "Product";
  81
  82         private ProductReqDetails productReqDetails;
  83         private RestResponse createProduct;
  84         private Product product;
  85
  86         public ProductCrudTest() {
  87                 super(name, ProductCrudTest.class.getName());
  88         }
  89
  90         @Test // (enabled=false)
  91         public void createAndGetAll() throws Exception {
  92                 createProductAndGet(UserRoleEnum.DESIGNER);
  93         }
  94
  95         private void createProductAndGet(UserRoleEnum user) throws Exception, IOException {
  96                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
  97                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
  98                 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_CREATED,
  99                                 createProduct.getErrorCode().intValue());
 100
 101                 RestResponse catalog = CatalogRestUtils.getCatalog(user.getUserId());
 102                 assertEquals("Check response code after get catalog", BaseRestUtils.STATUS_CODE_SUCCESS,
 103                                 catalog.getErrorCode().intValue());
 104
 105                 try {
 106                         JsonElement jElement = new JsonParser().parse(catalog.getResponse());
 107                         JsonObject jObject = jElement.getAsJsonObject();
 108                         JsonArray products = (JsonArray) jObject.get("products");
 109                         assertEquals("Check product array size", 1, products.size());
 110                         Iterator<JsonElement> iter = products.iterator();
 111                         while (iter.hasNext()) {
 112                                 JsonElement next = iter.next();
 113                                 Product product = ResponseParser.parseToObjectUsingMapper(next.toString(), Product.class);
 114                                 assertNotNull(product);
 115                                 assertEquals("Check product name", productReqDetails.getName(), product.getName());
 116                                 // Map<String, String> allVersions = product.getAllVersions();
 117                                 // assertEquals("Check product name", 1, allVersions.size());
 118                         }
 119
 120                 } catch (Exception e) {
 121                         log.debug("exception", e);
 122                 }
 123         }
 124
 125         @Test
 126         public void getAllNoProcduts() throws Exception {
 127
 128                 RestResponse catalog = CatalogRestUtils.getCatalog();
 129                 assertEquals("Check response code after get catalog", BaseRestUtils.STATUS_CODE_SUCCESS,
 130                                 catalog.getErrorCode().intValue());
 131
 132                 try {
 133                         JsonElement jElement = new JsonParser().parse(catalog.getResponse());
 134                         JsonObject jObject = jElement.getAsJsonObject();
 135                         JsonArray products = (JsonArray) jObject.get("products");
 136                         assertEquals("Check product array size", 0, products.size());
 137                 } catch (Exception e) {
 138                         log.debug("exception", e);
 139                 }
 140
 141         }
 142
 143         @Test
 144         public void getAllNoAttHeader() throws Exception {
 145                 String url = String.format(Urls.GET_CATALOG_DATA, config.getCatalogBeHost(), config.getCatalogBePort());
 146
 147                 List<String> headersToRemove = new ArrayList<String>();
 148                 headersToRemove.add(HttpHeaderEnum.USER_ID.getValue());
 149
 150                 RestResponse catalog = CatalogRestUtils.sendGetAndRemoveHeaders(url, null, headersToRemove);
 151                 assertEquals("Check response code after get catalog", BaseRestUtils.STATUS_CODE_MISSING_INFORMATION,
 152                                 catalog.getErrorCode().intValue());
 153
 154                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_INFORMATION.name(), new ArrayList<String>(),
 155                                 catalog.getResponse());
 156         }
 157
 158         @Test
 159         public void getAllWrongUser() throws Exception {
 160                 RestResponse catalog = CatalogRestUtils.getCatalog("kj8976");
 161                 assertEquals("Check response code after get catalog", BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION,
 162                                 catalog.getErrorCode().intValue());
 163
 164                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
 165                                 catalog.getResponse());
 166         }
 167
 168         @Test // (enabled=false)
 169         public void getAllWithProductStrategist_User() throws Exception {
 170                 createProductAndGet(UserRoleEnum.PRODUCT_STRATEGIST1);
 171         }
 172
 173         @Test // (enabled=false)
 174         public void getAllWithProductManager_User() throws Exception {
 175                 createProductAndGet(UserRoleEnum.PRODUCT_MANAGER1);
 176         }
 177
 178         @Test // (enabled=false)
 179         public void createProductNoCategories() throws Exception {
 180                 createProductWithCategories(null);
 181         }
 182
 183         @Test // (enabled=false)
 184         public void createProductOneGrouping() throws Exception {
 185                 // Category1->[Subcategory1->[Grouping1]]
 186                 createProductWithCategories(defaultCategories);
 187         }
 188
 189         @Test // (enabled=false)
 190         public void createProductTwoGroupingsSameSubCategory() throws Exception {
 191                 // Category1->Subcategory1->[Grouping1, Grouping11]
 192                 List<CategoryDefinition> addSecondGroupingToDefaultCategory = addSecondGroupingToDefaultCategory();
 193                 createProductWithCategories(addSecondGroupingToDefaultCategory);
 194         }
 195
 196         @Test // (enabled=false)
 197         public void createProductTwoSubsDifferentGroupings() throws Exception {
 198                 // Category1->[Subcategory1->[Grouping1,
 199                 // Grouping11],Subcategory2->[Grouping12]]
 200                 List<CategoryDefinition> addSubcategoryAndGroupingToDefaultCategory = addSubcategoryAndGroupingToDefaultCategory();
 201                 createProductWithCategories(addSubcategoryAndGroupingToDefaultCategory);
 202         }
 203
 204         @Test // (enabled=false)
 205         public void createManyGroupingsDiffCategories() throws Exception {
 206                 // [Category1->[Subcategory1->[Grouping1,
 207                 // Grouping11],Subcategory2->[Grouping12]],
 208                 // Category2->[Subcategory1->[Grouping1],Subcategory2->[Grouping1]],
 209                 // Category3->[Subcategory1->[Grouping11],Subcategory2->[Grouping11,
 210                 // Grouping22]]]
 211                 List<CategoryDefinition> addSubcategoryAndGroupingToDefaultCategory = addManyGroupingsDiffCategories();
 212                 createProductWithCategories(addSubcategoryAndGroupingToDefaultCategory);
 213         }
 214
 215         @Test // (enabled=false)
 216         public void createProductEmptyUserId() throws Exception {
 217                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 218                 User emptyUser = new User();
 219                 emptyUser.setUserId("");
 220                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, emptyUser);
 221                 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_MISSING_INFORMATION,
 222                                 createProduct.getErrorCode().intValue());
 223                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, INITIAL_PRODUCT_VERSION,
 224                                 emptyUser);
 225                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 226                                 expectedProduct, CREATE_AUDIT_ACTION, emptyUser, ActionStatus.MISSING_INFORMATION,
 227                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
 228                 constructFieldsForAuditValidation.setCURR_STATE("");
 229                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 230         }
 231
 232         @Test // (enabled=false)
 233         public void createProductNonExistingUserId() throws Exception {
 234                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 235                 User notExistingUser = new User();
 236                 notExistingUser.setUserId("jj6444");
 237                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, notExistingUser);
 238                 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION,
 239                                 createProduct.getErrorCode().intValue());
 240                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, INITIAL_PRODUCT_VERSION,
 241                                 notExistingUser);
 242                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 243                                 expectedProduct, CREATE_AUDIT_ACTION, notExistingUser, ActionStatus.RESTRICTED_OPERATION,
 244                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
 245                 constructFieldsForAuditValidation.setCURR_STATE("");
 246                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 247         }
 248
 249         @Test // (enabled=false)
 250         public void createProductInvalidJson() throws Exception {
 251                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 252                 RestResponse createProduct = ProductRestUtils.createProduct_Invalid_Json(productManager1.getUserId());
 253                 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
 254                                 createProduct.getErrorCode().intValue());
 255                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, INITIAL_PRODUCT_VERSION,
 256                                 productManager1);
 257                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 258                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.INVALID_CONTENT,
 259                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
 260                 constructFieldsForAuditValidation.setRESOURCE_NAME("");
 261                 constructFieldsForAuditValidation.setCURR_STATE("");
 262                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 263         }
 264
 265         @Test // (enabled=false)
 266         public void createProductAdminRoleNotAllowed() throws Exception {
 267                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 268                 User wrongRole = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 269                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, wrongRole);
 270                 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION,
 271                                 createProduct.getErrorCode().intValue());
 272                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, INITIAL_PRODUCT_VERSION,
 273                                 wrongRole);
 274                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 275                                 expectedProduct, CREATE_AUDIT_ACTION, wrongRole, ActionStatus.RESTRICTED_OPERATION,
 276                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
 277                 constructFieldsForAuditValidation.setCURR_STATE("");
 278                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 279         }
 280
 281         @Test // (enabled=false)
 282         public void createProductProductStrategistRoleNotAllowed() throws Exception {
 283                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 284                 User wrongRole = ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_STRATEGIST3);
 285                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, wrongRole);
 286                 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION,
 287                                 createProduct.getErrorCode().intValue());
 288                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, INITIAL_PRODUCT_VERSION,
 289                                 wrongRole);
 290                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 291                                 expectedProduct, CREATE_AUDIT_ACTION, wrongRole, ActionStatus.RESTRICTED_OPERATION,
 292                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
 293                 constructFieldsForAuditValidation.setCURR_VERSION("");
 294                 constructFieldsForAuditValidation.setCURR_STATE("");
 295                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 296         }
 297
 298         @Test // (enabled=false)
 299         public void getProductSuccessFlow() throws Exception {
 300                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 301                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 302                 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_CREATED,
 303                                 createProduct.getErrorCode().intValue());
 304
 305                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 306                                 productManager1.getUserId());
 307                 assertEquals("Check response code after getting created Product", BaseRestUtils.STATUS_CODE_SUCCESS,
 308                                 getProductRes.getErrorCode().intValue());
 309
 310                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 311                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
 312                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 313                                 ComponentOperationEnum.GET_COMPONENT);
 314         }
 315
 316         @Test // (enabled=false)
 317         public void getNonExistedProduct() throws Exception {
 318
 319                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 320                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 321                 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_CREATED,
 322                                 createProduct.getErrorCode().intValue());
 323
 324                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 325                                 productManager1.getUserId());
 326                 assertEquals("Check response code after getting created Product", BaseRestUtils.STATUS_CODE_SUCCESS,
 327                                 getProductRes.getErrorCode().intValue());
 328
 329                 Product product = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
 330                 assertEquals("Assert on product icon", productReqDetails.getName(), product.getName());
 331
 332                 RestResponse deleteProductRes = ProductRestUtils.deleteProduct(productReqDetails.getUniqueId(),
 333                                 productManager1.getUserId());
 334                 assertEquals("Check response code for deletign Product", BaseRestUtils.STATUS_CODE_SUCCESS,
 335                                 deleteProductRes.getErrorCode().intValue());
 336
 337                 RestResponse getProductAfterDeleteRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 338                                 productManager1.getUserId());
 339                 assertEquals("Check response code after getting deleted Product", BaseRestUtils.STATUS_CODE_NOT_FOUND,
 340                                 getProductAfterDeleteRes.getErrorCode().intValue());
 341         }
 342
 343         @Test // (enabled=false)
 344         public void getProductMissingHeader() throws Exception {
 345
 346                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 347                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 348                 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_CREATED,
 349                                 createProduct.getErrorCode().intValue());
 350
 351                 productManager1.setUserId(null);
 352                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 353                                 productManager1.getUserId());
 354                 assertEquals("Check response code after getting created Producuct with userId extracted from header",
 355                                 BaseRestUtils.STATUS_CODE_MISSING_INFORMATION, getProductRes.getErrorCode().intValue());
 356
 357         }
 358
 359         @Test // (enabled=false)
 360         public void getProductNonExistingUser() throws Exception {
 361                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 362                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 363                 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_CREATED,
 364                                 createProduct.getErrorCode().intValue());
 365
 366                 productManager1.setUserId("bt1111");
 367                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 368                                 productManager1.getUserId());
 369                 assertEquals("Check response code after getting created Producuct with non exsisting user",
 370                                 BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION, getProductRes.getErrorCode().intValue());
 371         }
 372
 373         @Test // (enabled=false)
 374         public void createProductAndGetProductWithDifferentUser() throws Exception {
 375                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 376                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 377                 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_CREATED,
 378                                 createProduct.getErrorCode().intValue());
 379                 User sdncProductStrategistUserAdminDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 380                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 381                                 sdncProductStrategistUserAdminDetails.getUserId());
 382                 assertEquals("Check response code after getting created Product different user role",
 383                                 BaseRestUtils.STATUS_CODE_SUCCESS, getProductRes.getErrorCode().intValue());
 384         }
 385
 386         // US594753 - Update Product metadata
 387
 388         // If user update "product name" we need to remove the old product name from
 389         // "Tags" and add the new product name instead - will handled in mew US
 390         @Test(enabled = false)
 391         public void updateProductAllFieldsByPM() throws Exception {
 392                 createProducrByPSAndCheckIn();
 393                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
 394                                 LifeCycleStatesEnum.CHECKOUT);
 395                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
 396                 // Update product
 397                 productReqDetails.setUniqueId(product.getUniqueId());
 398                 productReqDetails.setUUID(product.getUUID());
 399                 productReqDetails.setName("NewProductName");
 400                 List<CategoryDefinition> addSecondGroupingToDefaultCategory = addSecondGroupingToDefaultCategory();
 401                 productReqDetails.setFullName("New Full name");
 402                 productReqDetails.setActive("false");
 403                 productReqDetails.setContacts(
 404                                 Arrays.asList(productManager2.getUserId().toLowerCase(), productManager1.getUserId().toLowerCase()));
 405                 productReqDetails.setDescription("New Product Description");
 406                 productReqDetails.setIcon("asdfghjklqwertyuiozxcvbfv");
 407                 productReqDetails.setProjectCode("98765");
 408                 productReqDetails.setCategories(addSecondGroupingToDefaultCategory);
 409                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
 410                 ProductRestUtils.checkSuccess(updateProduct);
 411                 // productReqDetails.setTags(Arrays.asList(productReqDetails.getName(),
 412                 // productOldName));
 413                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
 414                 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
 415                 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
 416                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
 417                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
 418                 expectedProduct.setUUID(product.getUUID());
 419                 expectedProduct.setInvariantUUID(product.getInvariantUUID());
 420                 expectedProduct.setNormalizedName(productReqDetails.getName().toLowerCase());
 421                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 422                                 ComponentOperationEnum.UPDATE_COMPONENT);
 423         }
 424
 425         @Test // (enabled=false)
 426         public void updateProductByPS() throws Exception {
 427                 createProducrByPSAndCheckIn();
 428                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
 429                                 LifeCycleStatesEnum.CHECKOUT);
 430                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
 431                 productReqDetails.setUniqueId(product.getUniqueId());
 432                 productReqDetails.setUUID(product.getUUID());
 433                 productReqDetails.setDescription("New discription");
 434                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productStrategistUser1);
 435                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION,
 436                                 updateProduct.getErrorCode().intValue());
 437                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
 438                                 updateProduct.getResponse());
 439         }
 440
 441         @Test // (enabled=false)
 442         public void updateProductByAdmin() throws Exception {
 443                 createProducrByPSAndCheckIn();
 444                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
 445                                 LifeCycleStatesEnum.CHECKOUT);
 446                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
 447                 productReqDetails.setUniqueId(product.getUniqueId());
 448                 productReqDetails.setUUID(product.getUUID());
 449                 productReqDetails.setDescription("New discription");
 450                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, designerUser);
 451                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION,
 452                                 updateProduct.getErrorCode().intValue());
 453                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
 454                                 updateProduct.getResponse());
 455         }
 456
 457         @Test // (enabled=false)
 458         public void updateProductByNonPmUser() throws Exception {
 459                 createProducrByPSAndCheckIn();
 460                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
 461                                 LifeCycleStatesEnum.CHECKOUT);
 462                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
 463                 productReqDetails.setUniqueId(product.getUniqueId());
 464                 productReqDetails.setUUID(product.getUUID());
 465                 // Update product name
 466                 productReqDetails.setDescription("New discription");
 467                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, designerUser);
 468                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION,
 469                                 updateProduct.getErrorCode().intValue());
 470                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
 471                                 updateProduct.getResponse());
 472         }
 473
 474         @Test // (enabled=false)
 475         public void updateProductByNonAsdcUser() throws Exception {
 476                 createProducrByPSAndCheckIn();
 477                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
 478                                 LifeCycleStatesEnum.CHECKOUT);
 479                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
 480                 productReqDetails.setUniqueId(product.getUniqueId());
 481                 productReqDetails.setUUID(product.getUUID());
 482                 // Update product name
 483                 productReqDetails.setDescription("New discription");
 484                 User nonAsdcUser = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
 485                 nonAsdcUser.setUserId("bt789k");
 486                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, nonAsdcUser);
 487                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION,
 488                                 updateProduct.getErrorCode().intValue());
 489                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
 490                                 updateProduct.getResponse());
 491         }
 492
 493         @Test // (enabled=false)
 494         public void updateProductUserIdIsEmpty() throws Exception {
 495                 createProducrByPSAndCheckIn();
 496                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
 497                                 LifeCycleStatesEnum.CHECKOUT);
 498                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
 499                 productReqDetails.setUniqueId(product.getUniqueId());
 500                 productReqDetails.setUUID(product.getUUID());
 501                 // Update product name
 502                 productReqDetails.setDescription("New discription");
 503                 User nonAsdcUser = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
 504                 nonAsdcUser.setUserId("");
 505                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, nonAsdcUser);
 506                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_MISSING_INFORMATION,
 507                                 updateProduct.getErrorCode().intValue());
 508                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_INFORMATION.name(), new ArrayList<String>(),
 509                                 updateProduct.getResponse());
 510         }
 511
 512         @Test // (enabled=false)
 513         public void updateProductByNonProductOwner() throws Exception {
 514                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct(defaultCategories);
 515                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 516                 ProductRestUtils.checkCreateResponse(createProduct);
 517                 Product product = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 518                 productReqDetails.setUniqueId(product.getUniqueId());
 519                 productReqDetails.setUUID(product.getUUID());
 520                 productReqDetails.setDescription("New discription");
 521                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager2);
 522                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION,
 523                                 updateProduct.getErrorCode().intValue());
 524                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
 525                                 updateProduct.getResponse());
 526                 // Get Product and verify that metadata didn't change
 527                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 528                                 productManager1.getUserId());
 529                 ProductRestUtils.checkSuccess(getProduct);
 530                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 531                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
 532                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 533                                 ComponentOperationEnum.GET_COMPONENT);
 534         }
 535
 536         @Test // (enabled=false)
 537         public void updateProductNotInCheckoutState() throws Exception {
 538                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct(defaultCategories);
 539                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 540                 ProductRestUtils.checkCreateResponse(createProduct);
 541                 Product product = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 542                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
 543                                 LifeCycleStatesEnum.CHECKIN);
 544                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
 545                 productReqDetails.setUniqueId(product.getUniqueId());
 546                 productReqDetails.setUUID(product.getUUID());
 547                 // Update product name
 548                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
 549                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION,
 550                                 updateProduct.getErrorCode().intValue());
 551                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
 552                                 updateProduct.getResponse());
 553                 // Get Product and verify that metadata didn't change
 554                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 555                                 productManager1.getUserId());
 556                 ProductRestUtils.checkSuccess(getProduct);
 557                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 558                 expectedProduct.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
 559                 String valueFromJsonResponse = ResponseParser.getValueFromJsonResponse(changeProductLifeCycle.getResponse(),
 560                                 "lastUpdateDate");
 561                 expectedProduct.setLastUpdateDate(Long.parseLong(valueFromJsonResponse));
 562                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
 563                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 564                                 ComponentOperationEnum.UPDATE_COMPONENT);
 565         }
 566
 567         @Test // (enabled=false)
 568         public void updateProductNameIsEmpty() throws Exception {
 569                 createProducrByPSAndCheckIn();
 570                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
 571                                 LifeCycleStatesEnum.CHECKOUT);
 572                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
 573                 productReqDetails.setUniqueId(product.getUniqueId());
 574                 productReqDetails.setUUID(product.getUUID());
 575                 productReqDetails.setName("");
 576                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
 577                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
 578                                 updateProduct.getErrorCode().intValue());
 579                 ArrayList<String> varibales = new ArrayList<String>();
 580                 varibales.add(COMPONENT_TYPE);
 581                 varibales.add("abbreviated");
 582                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_ONE_OF_COMPONENT_NAMES.name(), varibales,
 583                                 updateProduct.getResponse());
 584                 // Get Product and verify that metadata didn't change
 585                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 586                                 productManager1.getUserId());
 587                 ProductRestUtils.checkSuccess(getProduct);
 588                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 589                 expectedProduct.setUniqueId(product.getUniqueId());
 590                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
 591                 expectedProduct.setVersion(product.getVersion());
 592                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 593                                 ComponentOperationEnum.UPDATE_COMPONENT);
 594         }
 595
 596         @Test // (enabled=false)
 597         public void updateProductNameIsNull() throws Exception {
 598                 createProducrByPSAndCheckIn();
 599                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager2,
 600                                 LifeCycleStatesEnum.CHECKOUT);
 601                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
 602                 // List<String> tags = productReqDetails.getTags();
 603                 // tags.removeAll(tags);
 604                 productReqDetails.setTags(new ArrayList<>());
 605                 productReqDetails.setUniqueId(product.getUniqueId());
 606                 productReqDetails.setUUID(product.getUUID());
 607                 productReqDetails.setName(null); // no update will be performed
 608                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager2);
 609                 ProductRestUtils.checkSuccess(updateProduct);
 610                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
 611                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager2);
 612                 expectedProduct.setUUID(product.getUUID());
 613                 expectedProduct.setInvariantUUID(product.getInvariantUUID());
 614                 expectedProduct.setNormalizedName(product.getName().toLowerCase());
 615                 expectedProduct.setName(product.getName());
 616                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 617                                 ComponentOperationEnum.UPDATE_COMPONENT);
 618         }
 619
 620         @Test // (enabled=false)
 621         public void updateProductNameLessThanMinLength() throws Exception {
 622                 createProducrByPSAndCheckIn();
 623                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
 624                                 LifeCycleStatesEnum.CHECKOUT);
 625                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
 626                 productReqDetails.setUniqueId(product.getUniqueId());
 627                 productReqDetails.setUUID(product.getUUID());
 628                 productReqDetails.setName("ABC"); // no update will be performed
 629                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
 630                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
 631                                 updateProduct.getErrorCode().intValue());
 632                 ArrayList<String> varibales = new ArrayList<String>();
 633                 varibales.add(COMPONENT_TYPE);
 634                 varibales.add("abbreviated");
 635                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_LENGTH.name(),
 636                                 varibales, updateProduct.getResponse());
 637                 // Get Product and verify that metadata didn't change
 638                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 639                                 productManager1.getUserId());
 640                 ProductRestUtils.checkSuccess(getProduct);
 641                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 642                 expectedProduct.setUniqueId(product.getUniqueId());
 643                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
 644                 expectedProduct.setVersion(product.getVersion());
 645                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 646                                 ComponentOperationEnum.UPDATE_COMPONENT);
 647         }
 648
 649         // If user update "product name" we need to remove the old product name from
 650         // "Tags" and add the new product name instead - will handled in mew US
 651         @Test(enabled = false)
 652         public void updateProductNameHasMinLength() throws Exception {
 653                 createProducrByPSAndCheckIn();
 654                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager2,
 655                                 LifeCycleStatesEnum.CHECKOUT);
 656                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
 657                 productReqDetails.setUniqueId(product.getUniqueId());
 658                 productReqDetails.setUUID(product.getUUID());
 659                 productReqDetails.setName("NewP");
 660                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager2);
 661                 ProductRestUtils.checkSuccess(updateProduct);
 662                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
 663                 productReqDetails.setLastUpdaterUserId(productManager2.getUserId());
 664                 productReqDetails.setLastUpdaterFullName(productManager2.getFullName());
 665                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
 666                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager2);
 667                 expectedProduct.setUUID(product.getUUID());
 668                 expectedProduct.setInvariantUUID(product.getInvariantUUID());
 669                 expectedProduct.setNormalizedName(productReqDetails.getName().toLowerCase());
 670                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 671                                 ComponentOperationEnum.UPDATE_COMPONENT);
 672         }
 673
 674         // If user update "product name" we need to remove the old product name from
 675         // "Tags" and add the new product name instead - will handled in mew US
 676         // DE193857 - Normalized Name is not removing special characters
 677         @Test(enabled = false)
 678         public void updateProductNameMaxLength() throws Exception {
 679                 createProducrByPSAndCheckIn();
 680                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
 681                                 LifeCycleStatesEnum.CHECKOUT);
 682                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
 683                 // Update product name
 684                 productReqDetails.setUniqueId(product.getUniqueId());
 685                 productReqDetails.setUUID(product.getUUID());
 686                 productReqDetails.setName("Ac_2B3U4k mSKnob-u.j-uGgP");
 687                 String newNormalizedName = "ac2b3u4kmsknobujuggp";
 688                 String newName = "Ac_2B3U4k MSKnob-u.j-uGgP";
 689                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
 690                 ProductRestUtils.checkSuccess(updateProduct);
 691                 productReqDetails.setTags(Arrays.asList(newName));
 692                 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
 693                 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
 694                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
 695                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
 696                 expectedProduct.setUUID(product.getUUID());
 697                 expectedProduct.setInvariantUUID(product.getInvariantUUID());
 698                 expectedProduct.setNormalizedName(newNormalizedName);
 699                 expectedProduct.setName(newName);
 700                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 701                                 ComponentOperationEnum.UPDATE_COMPONENT);
 702         }
 703
 704         @Test // (enabled=false)
 705         public void updateProductNameExceedMaxLength() throws Exception {
 706                 createProducrByPSAndCheckIn();
 707                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
 708                                 LifeCycleStatesEnum.CHECKOUT);
 709                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
 710                 productReqDetails.setUniqueId(product.getUniqueId());
 711                 productReqDetails.setUUID(product.getUUID());
 712                 productReqDetails.setName("Ac_2B3U4k mSKnob-u.j-uGgPx");
 713                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
 714                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
 715                                 updateProduct.getErrorCode().intValue());
 716                 ArrayList<String> varibales = new ArrayList<String>();
 717                 varibales.add(COMPONENT_TYPE);
 718                 varibales.add("abbreviated");
 719                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_LENGTH.name(),
 720                                 varibales, updateProduct.getResponse());
 721                 // Get Product and verify that metadata didn't change
 722                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 723                                 productManager1.getUserId());
 724                 ProductRestUtils.checkSuccess(getProduct);
 725                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 726                 expectedProduct.setUniqueId(product.getUniqueId());
 727                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
 728                 expectedProduct.setVersion(product.getVersion());
 729                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 730                                 ComponentOperationEnum.UPDATE_COMPONENT);
 731         }
 732
 733         @Test // (enabled=false)
 734         public void updateProductNameAlreadyExist() throws Exception {
 735                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct(defaultCategories);
 736                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager2);
 737                 ProductRestUtils.checkCreateResponse(createProduct);
 738                 Product product1 = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 739                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product1, productManager2,
 740                                 LifeCycleStatesEnum.CHECKIN);
 741                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
 742                 productReqDetails.setName("Product2000");
 743                 // productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
 744                 createProduct = ProductRestUtils.createProduct(productReqDetails, productManager2);
 745                 ProductRestUtils.checkCreateResponse(createProduct);
 746                 Product product2 = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 747                 changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product2, productManager2,
 748                                 LifeCycleStatesEnum.CHECKIN);
 749                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
 750                 changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product2, productManager2,
 751                                 LifeCycleStatesEnum.CHECKOUT);
 752                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
 753                 productReqDetails.setUniqueId(product2.getUniqueId());
 754                 productReqDetails.setUUID(product2.getUUID());
 755                 productReqDetails.setName(product1.getName());
 756                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager2);
 757                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_ALREADY_EXISTS,
 758                                 updateProduct.getErrorCode().intValue());
 759                 ArrayList<String> varibales = new ArrayList<String>();
 760                 varibales.add(COMPONENT_TYPE);
 761                 varibales.add(product1.getName());
 762                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_NAME_ALREADY_EXIST.name(), varibales,
 763                                 updateProduct.getResponse());
 764                 // Get Product and verify that metadata didn't change
 765                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 766                                 productManager2.getUserId());
 767                 ProductRestUtils.checkSuccess(getProduct);
 768                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
 769                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 770                 expectedProduct.setUniqueId(product2.getUniqueId());
 771                 expectedProduct.setVersion(product2.getVersion());
 772                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 773                                 ComponentOperationEnum.UPDATE_COMPONENT);
 774         }
 775
 776         // DE193857 - Normalized Name is not removing special characters
 777         // If user update "product name" we need to remove the old product name from
 778         // "Tags" and add the new product name instead - will handled in mew US
 779         @Test(enabled = false)
 780         public void updateProductNameAllowedCharacters() throws Exception {
 781                 createProducrByPSAndCheckIn();
 782                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
 783                                 LifeCycleStatesEnum.CHECKOUT);
 784                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
 785                 // Update product name
 786                 productReqDetails.setUniqueId(product.getUniqueId());
 787                 productReqDetails.setUUID(product.getUUID());
 788                 productReqDetails.setName("A_BU4k m&K=o#b-u.j-uG'g+P"); // Allowed
 789                                                                                                                                 // characters
 790                                                                                                                                 // [a-z,A-Z,0-9]
 791                                                                                                                                 // , ‘ ‘
 792                                                                                                                                 // (space),
 793                                                                                                                                 // ampersand
 794                                                                                                                                 // "&", dash
 795                                                                                                                                 // “-“, plus
 796                                                                                                                                 // "+", period
 797                                                                                                                                 // ".",
 798                                                                                                                                 // apostrophe
 799                                                                                                                                 // "'", hashtag
 800                                                                                                                                 // "#", equal
 801                                                                                                                                 // "=", period
 802                                                                                                                                 // ":", at "@",
 803                                                                                                                                 // and
 804                                                                                                                                 // underscore
 805                                                                                                                                 // "_"
 806                 String newNormalizedName = "abu4km&kobujuggp";
 807                 String newName = "A_BU4k M&K=o#b-u.j-uG'g+P";
 808                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
 809                 ProductRestUtils.checkSuccess(updateProduct);
 810                 productReqDetails.setTags(Arrays.asList(newName));
 811                 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
 812                 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
 813                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
 814                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
 815                 expectedProduct.setUUID(product.getUUID());
 816                 expectedProduct.setInvariantUUID(product.getInvariantUUID());
 817                 expectedProduct.setNormalizedName(newNormalizedName);
 818                 expectedProduct.setName(newName);
 819                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 820                                 ComponentOperationEnum.UPDATE_COMPONENT);
 821         }
 822
 823         // If user update "product name" we need to remove the old product name from
 824         // "Tags" and add the new product name instead - will handled in mew US
 825         @Test(enabled = false)
 826         public void updateProductNameRemoveSpaceFromBeginning() throws Exception {
 827                 createProducrByPSAndCheckIn();
 828                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
 829                                 LifeCycleStatesEnum.CHECKOUT);
 830                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
 831                 productReqDetails.setUniqueId(product.getUniqueId());
 832                 productReqDetails.setUUID(product.getUUID());
 833                 productReqDetails.setName("      asdfg");
 834                 String newNormalizedName = "asdfg";
 835                 String newName = "Asdfg";
 836                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
 837                 ProductRestUtils.checkSuccess(updateProduct);
 838                 // productReqDetails.setTags(Arrays.asList(newName, productOldName));
 839                 productReqDetails.setTags(Arrays.asList(newName));
 840                 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
 841                 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
 842                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
 843                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
 844                 expectedProduct.setUUID(product.getUUID());
 845                 expectedProduct.setInvariantUUID(product.getInvariantUUID());
 846                 expectedProduct.setNormalizedName(newNormalizedName);
 847                 expectedProduct.setName(newName);
 848                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 849                                 ComponentOperationEnum.UPDATE_COMPONENT);
 850         }
 851
 852         // If user update "product name" we need to remove the old product name from
 853         // "Tags" and add the new product name instead - will handled in mew US
 854         @Test(enabled = false)
 855         public void updateProductNameRemoveSpaceFromEnd() throws Exception {
 856                 createProducrByPSAndCheckIn();
 857                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
 858                                 LifeCycleStatesEnum.CHECKOUT);
 859                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
 860                 productReqDetails.setUniqueId(product.getUniqueId());
 861                 productReqDetails.setUUID(product.getUUID());
 862                 productReqDetails.setName("asdfg fc        ");
 863                 String newNormalizedName = "asdfgfc";
 864                 String newName = "Asdfg Fc";
 865                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
 866                 ProductRestUtils.checkSuccess(updateProduct);
 867                 // productReqDetails.setTags(Arrays.asList(newName, productOldName));
 868                 productReqDetails.setTags(Arrays.asList(newName));
 869                 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
 870                 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
 871                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
 872                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
 873                 expectedProduct.setUUID(product.getUUID());
 874                 expectedProduct.setInvariantUUID(product.getInvariantUUID());
 875                 expectedProduct.setNormalizedName(newNormalizedName);
 876                 expectedProduct.setName(newName);
 877                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 878                                 ComponentOperationEnum.UPDATE_COMPONENT);
 879         }
 880
 881         //// DE193857 - Normalized Name is not removing special characters
 882         // If user update "product name" we need to remove the old product name from
 883         //// "Tags" and add the new product name instead - will handled in mew US
 884         @Test(enabled = false)
 885         public void updateProductNameRemoveExtraNonAlphanumericChars() throws Exception {
 886                 createProducrByPSAndCheckIn();
 887                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
 888                                 LifeCycleStatesEnum.CHECKOUT);
 889                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
 890                 productReqDetails.setUniqueId(product.getUniqueId());
 891                 productReqDetails.setUUID(product.getUUID());
 892                 productReqDetails.setName("A__k &&==##---u..hG'''+++");
 893                 String newNormalizedName = "akhg";
 894                 String newName = "A_k &=#-u.hG'+";
 895                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
 896                 ProductRestUtils.checkSuccess(updateProduct);
 897                 // productReqDetails.setTags(Arrays.asList(newName, productOldName));
 898                 productReqDetails.setTags(Arrays.asList(newName));
 899                 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
 900                 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
 901                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
 902                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
 903                 expectedProduct.setUUID(product.getUUID());
 904                 expectedProduct.setInvariantUUID(product.getInvariantUUID());
 905                 expectedProduct.setNormalizedName(newNormalizedName);
 906                 expectedProduct.setName(newName);
 907                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 908                                 ComponentOperationEnum.UPDATE_COMPONENT);
 909         }
 910
 911         // If user update "product name" we need to remove the old product name from
 912         // "Tags" and add the new product name instead - will handled in mew US
 913         @Test(enabled = false)
 914         public void updateProductNameValidationStartWithNumber() throws Exception {
 915                 createProducrByPSAndCheckIn();
 916                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
 917                                 LifeCycleStatesEnum.CHECKOUT);
 918                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
 919                 productReqDetails.setUniqueId(product.getUniqueId());
 920                 productReqDetails.setUUID(product.getUUID());
 921                 productReqDetails.setName("1000Ab");
 922                 String newNormalizedName = productReqDetails.getName().toLowerCase();
 923                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
 924                 ProductRestUtils.checkSuccess(updateProduct);
 925                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
 926                 // productReqDetails.setTags(Arrays.asList(productReqDetails.getName(),
 927                 // productOldName));
 928                 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
 929                 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
 930                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
 931                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
 932                 expectedProduct.setUUID(product.getUUID());
 933                 expectedProduct.setInvariantUUID(product.getInvariantUUID());
 934                 expectedProduct.setNormalizedName(newNormalizedName);
 935                 expectedProduct.setName(productReqDetails.getName());
 936                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 937                                 ComponentOperationEnum.UPDATE_COMPONENT);
 938         }
 939
 940         @Test // (enabled=false)
 941         public void updateProductNameValidationStartWithNonAlphaNumeric() throws Exception {
 942                 createProducrByPSAndCheckIn();
 943                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
 944                                 LifeCycleStatesEnum.CHECKOUT);
 945                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
 946                 productReqDetails.setUniqueId(product.getUniqueId());
 947                 productReqDetails.setUUID(product.getUUID());
 948                 productReqDetails.setName("_1000Ab");
 949                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
 950                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
 951                                 updateProduct.getErrorCode().intValue());
 952                 ArrayList<String> varibales = new ArrayList<String>();
 953                 varibales.add(COMPONENT_TYPE);
 954                 varibales.add("abbreviated");
 955                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_FORMAT.name(),
 956                                 varibales, updateProduct.getResponse());
 957                 // Get Product and verify that metadata didn't change
 958                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 959                                 productManager1.getUserId());
 960                 ProductRestUtils.checkSuccess(getProduct);
 961                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 962                 expectedProduct.setUniqueId(product.getUniqueId());
 963                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
 964                 expectedProduct.setVersion(product.getVersion());
 965                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 966                                 ComponentOperationEnum.UPDATE_COMPONENT);
 967         }
 968
 969         @Test // (enabled=false)
 970         public void updateProductFullNameIsEmpty() throws Exception {
 971                 createProducrByPSAndCheckIn();
 972                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
 973                                 LifeCycleStatesEnum.CHECKOUT);
 974                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
 975                 productReqDetails.setUniqueId(product.getUniqueId());
 976                 productReqDetails.setUUID(product.getUUID());
 977                 productReqDetails.setFullName("");
 978                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
 979                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
 980                                 updateProduct.getErrorCode().intValue());
 981                 ArrayList<String> varibales = new ArrayList<String>();
 982                 varibales.add(COMPONENT_TYPE);
 983                 varibales.add("full");
 984                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_ONE_OF_COMPONENT_NAMES.name(), varibales,
 985                                 updateProduct.getResponse());
 986                 // Get Product and verify that metadata didn't change
 987                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 988                                 productManager1.getUserId());
 989                 ProductRestUtils.checkSuccess(getProduct);
 990                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 991                 expectedProduct.setUniqueId(product.getUniqueId());
 992                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
 993                 expectedProduct.setVersion(product.getVersion());
 994                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 995                                 ComponentOperationEnum.UPDATE_COMPONENT);
 996         }
 997
 998         @Test // (enabled=false)
 999         public void updateProductFullNameIsNull() throws Exception {
1000                 createProducrByPSAndCheckIn();
1001                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1002                                 LifeCycleStatesEnum.CHECKOUT);
1003                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1004                 productReqDetails.setUniqueId(product.getUniqueId());
1005                 productReqDetails.setUUID(product.getUUID());
1006                 productReqDetails.setFullName(null);
1007                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1008                 ProductRestUtils.checkSuccess(updateProduct);
1009                 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
1010                 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
1011                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
1012                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
1013                 expectedProduct.setUUID(product.getUUID());
1014                 expectedProduct.setNormalizedName(product.getNormalizedName());
1015                 expectedProduct.setInvariantUUID(product.getInvariantUUID());
1016                 expectedProduct.setFullName(product.getFullName());
1017                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1018                                 ComponentOperationEnum.UPDATE_COMPONENT);
1019         }
1020
1021         @Test // (enabled=false)
1022         public void updateProductFullNameHasMinLength() throws Exception {
1023                 createProducrByPSAndCheckIn();
1024                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1025                                 LifeCycleStatesEnum.CHECKOUT);
1026                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1027                 productReqDetails.setUniqueId(product.getUniqueId());
1028                 productReqDetails.setUUID(product.getUUID());
1029                 productReqDetails.setFullName("asdc");
1030                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1031                 ProductRestUtils.checkSuccess(updateProduct);
1032                 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
1033                 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
1034                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
1035                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
1036                 expectedProduct.setUUID(product.getUUID());
1037                 expectedProduct.setNormalizedName(product.getNormalizedName());
1038                 expectedProduct.setInvariantUUID(product.getInvariantUUID());
1039                 expectedProduct.setFullName(productReqDetails.getFullName());
1040                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1041                                 ComponentOperationEnum.UPDATE_COMPONENT);
1042         }
1043
1044         @Test // (enabled=false)
1045         public void updateProductFullNameHasMaxLength() throws Exception {
1046                 createProducrByPSAndCheckIn();
1047                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1048                                 LifeCycleStatesEnum.CHECKOUT);
1049                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1050                 productReqDetails.setUniqueId(product.getUniqueId());
1051                 productReqDetails.setUUID(product.getUUID());
1052                 productReqDetails.setFullName(
1053                                 "1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk");
1054                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1055                 ProductRestUtils.checkSuccess(updateProduct);
1056                 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
1057                 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
1058                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
1059                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
1060                 expectedProduct.setUUID(product.getUUID());
1061                 expectedProduct.setNormalizedName(product.getNormalizedName());
1062                 expectedProduct.setInvariantUUID(product.getInvariantUUID());
1063                 expectedProduct.setFullName(productReqDetails.getFullName());
1064                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1065                                 ComponentOperationEnum.UPDATE_COMPONENT);
1066         }
1067
1068         @Test // (enabled=false)
1069         public void updateProductFullNamelessThanMinLength() throws Exception {
1070                 createProducrByPSAndCheckIn();
1071                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1072                                 LifeCycleStatesEnum.CHECKOUT);
1073                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1074                 productReqDetails.setUniqueId(product.getUniqueId());
1075                 productReqDetails.setUUID(product.getUUID());
1076                 productReqDetails.setFullName("123");
1077                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1078                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1079                                 updateProduct.getErrorCode().intValue());
1080                 ArrayList<String> varibales = new ArrayList<String>();
1081                 varibales.add(COMPONENT_TYPE);
1082                 varibales.add("full");
1083                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_LENGTH.name(),
1084                                 varibales, updateProduct.getResponse());
1085                 // Get Product and verify that metadata didn't change
1086                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1087                                 productManager1.getUserId());
1088                 ProductRestUtils.checkSuccess(getProduct);
1089                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1090                 expectedProduct.setUniqueId(product.getUniqueId());
1091                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1092                 expectedProduct.setVersion(product.getVersion());
1093                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1094                                 ComponentOperationEnum.UPDATE_COMPONENT);
1095         }
1096
1097         @Test // (enabled=false)
1098         public void updateProductFullNameExceedMaxLength() throws Exception {
1099                 createProducrByPSAndCheckIn();
1100                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1101                                 LifeCycleStatesEnum.CHECKOUT);
1102                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1103                 productReqDetails.setUniqueId(product.getUniqueId());
1104                 productReqDetails.setUUID(product.getUUID());
1105                 productReqDetails.setFullName(
1106                                 "1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjkx");
1107                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1108                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1109                                 updateProduct.getErrorCode().intValue());
1110                 ArrayList<String> varibales = new ArrayList<String>();
1111                 varibales.add(COMPONENT_TYPE);
1112                 varibales.add("full");
1113                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_LENGTH.name(),
1114                                 varibales, updateProduct.getResponse());
1115                 // Get Product and verify that metadata didn't change
1116                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1117                                 productManager1.getUserId());
1118                 ProductRestUtils.checkSuccess(getProduct);
1119                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1120                 expectedProduct.setUniqueId(product.getUniqueId());
1121                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1122                 expectedProduct.setVersion(product.getVersion());
1123                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1124                                 ComponentOperationEnum.UPDATE_COMPONENT);
1125         }
1126
1127         // DE193947
1128         @Test
1129         public void updateProductFullNameWithSpecialCharacters() throws Exception {
1130                 char invalidChars[] = { '~', '!', '%', '^', '*', '(', ')', '"', '{', '}', '[', ']', '?', '>', '<', '/', '|',
1131                                 '\\', ',', '$', '#', '@', '+' };
1132                 String fullName = "avbng";
1133                 createProducrByPSAndCheckIn();
1134                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1135                                 LifeCycleStatesEnum.CHECKOUT);
1136                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1137                 productReqDetails.setUniqueId(product.getUniqueId());
1138                 productReqDetails.setUUID(product.getUUID());
1139                 for (int i = 0; i < invalidChars.length; i++) {
1140                         productReqDetails.setFullName(fullName + invalidChars[i]);
1141                         RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1142                         assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS,
1143                                         updateProduct.getErrorCode().intValue());
1144                 }
1145         }
1146
1147         @Test // (enabled=false)
1148         public void updateProductFullNameValidCharactersCharacters01() throws Exception {
1149                 createProducrByPSAndCheckIn();
1150                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1151                                 LifeCycleStatesEnum.CHECKOUT);
1152                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1153                 productReqDetails.setUniqueId(product.getUniqueId());
1154                 productReqDetails.setUUID(product.getUUID());
1155                 productReqDetails.setFullName("qwertyuiopasdfghjklzxcvbnm1234567890<b>Bold<</b>");
1156                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1157                 ProductRestUtils.checkSuccess(updateProduct);
1158                 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
1159                 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
1160                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
1161                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
1162                 expectedProduct.setUUID(product.getUUID());
1163                 expectedProduct.setNormalizedName(product.getNormalizedName());
1164                 expectedProduct.setInvariantUUID(product.getInvariantUUID());
1165                 expectedProduct.setFullName("qwertyuiopasdfghjklzxcvbnm1234567890Bold&lt;");
1166                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1167                                 ComponentOperationEnum.UPDATE_COMPONENT);
1168         }
1169
1170         @Test // (enabled=false)
1171         public void updateProductFullNameRemoveExtraSpaces() throws Exception {
1172                 createProducrByPSAndCheckIn();
1173                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1174                                 LifeCycleStatesEnum.CHECKOUT);
1175                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1176                 productReqDetails.setUniqueId(product.getUniqueId());
1177                 productReqDetails.setUUID(product.getUUID());
1178                 productReqDetails.setFullName("Abbaaa  a1");
1179                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1180                 ProductRestUtils.checkSuccess(updateProduct);
1181                 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
1182                 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
1183                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
1184                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
1185                 expectedProduct.setUUID(product.getUUID());
1186                 expectedProduct.setNormalizedName(product.getNormalizedName());
1187                 expectedProduct.setInvariantUUID(product.getInvariantUUID());
1188                 expectedProduct.setFullName("Abbaaa a1");
1189                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1190                                 ComponentOperationEnum.UPDATE_COMPONENT);
1191         }
1192
1193         @Test // (enabled=false)
1194         public void updateProductDescriptionIsEmpty() throws Exception {
1195                 createProducrByPSAndCheckIn();
1196                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1197                                 LifeCycleStatesEnum.CHECKOUT);
1198                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1199                 productReqDetails.setUniqueId(product.getUniqueId());
1200                 productReqDetails.setUUID(product.getUUID());
1201                 productReqDetails.setDescription("");
1202                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1203                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1204                                 updateProduct.getErrorCode().intValue());
1205                 ArrayList<String> varibales = new ArrayList<String>();
1206                 varibales.add(COMPONENT_TYPE);
1207                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_MISSING_DESCRIPTION.name(), varibales,
1208                                 updateProduct.getResponse());
1209                 // Get Product and verify that metadata didn't change
1210                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1211                                 productManager1.getUserId());
1212                 ProductRestUtils.checkSuccess(getProduct);
1213                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1214                 expectedProduct.setUniqueId(product.getUniqueId());
1215                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1216                 expectedProduct.setVersion(product.getVersion());
1217                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1218                                 ComponentOperationEnum.UPDATE_COMPONENT);
1219         }
1220
1221         @Test // (enabled=false)
1222         public void updateProductDescriptionIsNull() throws Exception {
1223                 createProducrByPSAndCheckIn();
1224                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1225                                 LifeCycleStatesEnum.CHECKOUT);
1226                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1227                 productReqDetails.setUniqueId(product.getUniqueId());
1228                 productReqDetails.setUUID(product.getUUID());
1229                 productReqDetails.setDescription(null);
1230                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1231                 ProductRestUtils.checkSuccess(updateProduct);
1232                 // Get Product and verify that metadata didn't change
1233                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1234                                 productManager1.getUserId());
1235                 ProductRestUtils.checkSuccess(getProduct);
1236                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1237                 expectedProduct.setUniqueId(product.getUniqueId());
1238                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1239                 expectedProduct.setVersion(product.getVersion());
1240                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1241                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1242                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1243                                 ComponentOperationEnum.UPDATE_COMPONENT);
1244         }
1245
1246         @Test(enabled = false)
1247         public void updateProductDescriptionValidCharacters01() throws Exception {
1248                 createProducrByPSAndCheckIn();
1249                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1250                                 LifeCycleStatesEnum.CHECKOUT);
1251                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1252                 productReqDetails.setUniqueId(product.getUniqueId());
1253                 productReqDetails.setUUID(product.getUUID());
1254                 productReqDetails.setDescription("~!@#$%^&*()_+<>?qwertyuiopasdfghjklzxcvbnm1234567890#");
1255                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1256                 ProductRestUtils.checkSuccess(updateProduct);
1257                 // Get Product and verify that metadata didn't change
1258                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1259                                 productManager1.getUserId());
1260                 ProductRestUtils.checkSuccess(getProduct);
1261                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1262                 expectedProduct.setUniqueId(product.getUniqueId());
1263                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1264                 expectedProduct.setDescription("~!@#$%^&amp;*()_+&lt;&gt;?qwertyuiopasdfghjklzxcvbnm1234567890#");
1265                 expectedProduct.setVersion(product.getVersion());
1266                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1267                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1268                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1269                                 ComponentOperationEnum.UPDATE_COMPONENT);
1270         }
1271
1272         @Test // (enabled=false)
1273         public void updateProductDescriptionValidCharacters02() throws Exception {
1274                 createProducrByPSAndCheckIn();
1275                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1276                                 LifeCycleStatesEnum.CHECKOUT);
1277                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1278                 productReqDetails.setUniqueId(product.getUniqueId());
1279                 productReqDetails.setUUID(product.getUUID());
1280                 productReqDetails.setDescription("qwertyuiopasdfghjklzxcvbnm1234567890<b>Bold<</b>");
1281                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1282                 ProductRestUtils.checkSuccess(updateProduct);
1283                 // Get Product and verify that metadata didn't change
1284                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1285                                 productManager1.getUserId());
1286                 ProductRestUtils.checkSuccess(getProduct);
1287                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1288                 expectedProduct.setUniqueId(product.getUniqueId());
1289                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1290                 expectedProduct.setDescription("qwertyuiopasdfghjklzxcvbnm1234567890Bold<");
1291                 expectedProduct.setVersion(product.getVersion());
1292                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1293                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1294                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1295                                 ComponentOperationEnum.UPDATE_COMPONENT);
1296         }
1297
1298         @Test // (enabled=false)
1299         public void updateProductDescriptionInValidCharacters() throws Exception {
1300                 createProducrByPSAndCheckIn();
1301                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1302                                 LifeCycleStatesEnum.CHECKOUT);
1303                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1304                 productReqDetails.setUniqueId(product.getUniqueId());
1305                 productReqDetails.setUUID(product.getUUID());
1306                 productReqDetails.setDescription("מה");
1307                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1308                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1309                                 updateProduct.getErrorCode().intValue());
1310                 ArrayList<String> varibales = new ArrayList<String>();
1311                 varibales.add(COMPONENT_TYPE);
1312                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_INVALID_DESCRIPTION.name(), varibales,
1313                                 updateProduct.getResponse());
1314                 // Get Product and verify that metadata didn't change
1315                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1316                                 productManager1.getUserId());
1317                 ProductRestUtils.checkSuccess(getProduct);
1318                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1319                 expectedProduct.setUniqueId(product.getUniqueId());
1320                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1321                 expectedProduct.setVersion(product.getVersion());
1322                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1323                                 ComponentOperationEnum.UPDATE_COMPONENT);
1324         }
1325
1326         @Test // (enabled=false)
1327         public void updateProductDescriptionRemoveSpacesFromBeginning() throws Exception {
1328                 createProducrByPSAndCheckIn();
1329                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1330                                 LifeCycleStatesEnum.CHECKOUT);
1331                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1332                 productReqDetails.setUniqueId(product.getUniqueId());
1333                 productReqDetails.setUUID(product.getUUID());
1334                 productReqDetails.setDescription("   abcd12345 g");
1335                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1336                 ProductRestUtils.checkSuccess(updateProduct);
1337                 // Get Product and verify that metadata didn't change
1338                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1339                                 productManager1.getUserId());
1340                 ProductRestUtils.checkSuccess(getProduct);
1341                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1342                 expectedProduct.setUniqueId(product.getUniqueId());
1343                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1344                 expectedProduct.setDescription(" abcd12345 g");
1345                 expectedProduct.setVersion(product.getVersion());
1346                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1347                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1348                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1349                                 ComponentOperationEnum.UPDATE_COMPONENT);
1350         }
1351
1352         @Test // (enabled=false)
1353         public void updateProductDescriptionRemoveSpacesFromTheEnd() throws Exception {
1354                 createProducrByPSAndCheckIn();
1355                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1356                                 LifeCycleStatesEnum.CHECKOUT);
1357                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1358                 productReqDetails.setUniqueId(product.getUniqueId());
1359                 productReqDetails.setUUID(product.getUUID());
1360                 productReqDetails.setDescription("abcd12345  gdf     ");
1361                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1362                 ProductRestUtils.checkSuccess(updateProduct);
1363                 // Get Product and verify that metadata didn't change
1364                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1365                                 productManager1.getUserId());
1366                 ProductRestUtils.checkSuccess(getProduct);
1367                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1368                 expectedProduct.setUniqueId(product.getUniqueId());
1369                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1370                 expectedProduct.setDescription("abcd12345 gdf ");
1371                 expectedProduct.setVersion(product.getVersion());
1372                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1373                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1374                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1375                                 ComponentOperationEnum.UPDATE_COMPONENT);
1376         }
1377
1378         @Test // (enabled=false)
1379         public void updateProductDescriptionMaxLength() throws Exception {
1380                 createProducrByPSAndCheckIn();
1381                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1382                                 LifeCycleStatesEnum.CHECKOUT);
1383                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1384                 productReqDetails.setUniqueId(product.getUniqueId());
1385                 productReqDetails.setUUID(product.getUUID());
1386                 String description = "1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfg";
1387                 productReqDetails.setDescription(description);
1388                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1389                 ProductRestUtils.checkSuccess(updateProduct);
1390                 // Get Product and verify that metadata change
1391                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1392                                 productManager1.getUserId());
1393                 ProductRestUtils.checkSuccess(getProduct);
1394                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1395                 expectedProduct.setUniqueId(product.getUniqueId());
1396                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1397                 expectedProduct.setDescription(description);
1398                 expectedProduct.setVersion(product.getVersion());
1399                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1400                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1401                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1402                                 ComponentOperationEnum.UPDATE_COMPONENT);
1403         }
1404
1405         @Test // (enabled=false)
1406         public void updateProductDescriptionExceedMaxLength() throws Exception {
1407                 createProducrByPSAndCheckIn();
1408                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1409                                 LifeCycleStatesEnum.CHECKOUT);
1410                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1411                 productReqDetails.setUniqueId(product.getUniqueId());
1412                 productReqDetails.setUUID(product.getUUID());
1413                 String description = "01234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjk aa1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfg";
1414                 productReqDetails.setDescription(description);
1415                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1416                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1417                                 updateProduct.getErrorCode().intValue());
1418                 ArrayList<String> varibales = new ArrayList<String>();
1419                 varibales.add(COMPONENT_TYPE);
1420                 varibales.add("1024");
1421                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_DESCRIPTION_EXCEEDS_LIMIT.name(),
1422                                 varibales, updateProduct.getResponse());
1423                 // Get Product and verify that metadata didn't change
1424                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1425                                 productManager1.getUserId());
1426                 ProductRestUtils.checkSuccess(getProduct);
1427                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1428                 expectedProduct.setUniqueId(product.getUniqueId());
1429                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1430                 expectedProduct.setVersion(product.getVersion());
1431                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1432                                 ComponentOperationEnum.UPDATE_COMPONENT);
1433         }
1434
1435         @Test // (enabled=false)
1436         public void updateProductTagIsEmpty() throws Exception {
1437                 createProducrByPSAndCheckIn();
1438                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1439                                 LifeCycleStatesEnum.CHECKOUT);
1440                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1441                 productReqDetails.setUniqueId(product.getUniqueId());
1442                 productReqDetails.setUUID(product.getUUID());
1443                 productReqDetails.setTags(Arrays.asList(""));
1444                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1445                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1446                                 updateProduct.getErrorCode().intValue());
1447                 ArrayList<String> varibales = new ArrayList<String>();
1448                 varibales.add(COMPONENT_TYPE);
1449                 varibales.add("tag");
1450                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_FIELD_FORMAT.name(), varibales,
1451                                 updateProduct.getResponse());
1452                 // Get Product and verify that metadata didn't change
1453                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1454                                 productManager1.getUserId());
1455                 ProductRestUtils.checkSuccess(getProduct);
1456                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1457                 expectedProduct.setUniqueId(product.getUniqueId());
1458                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1459                 expectedProduct.setVersion(product.getVersion());
1460                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1461                                 ComponentOperationEnum.UPDATE_COMPONENT);
1462         }
1463
1464         @Test // (enabled=false)
1465         public void updateProductTagIsNull() throws Exception {
1466                 createProducrByPSAndCheckIn();
1467                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1468                                 LifeCycleStatesEnum.CHECKOUT);
1469                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1470                 productReqDetails.setUniqueId(product.getUniqueId());
1471                 productReqDetails.setUUID(product.getUUID());
1472                 productReqDetails.setTags(null);
1473                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1474                 ProductRestUtils.checkSuccess(updateProduct);
1475                 // Get Product and verify that metadata didn't change
1476                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1477                                 productManager1.getUserId());
1478                 ProductRestUtils.checkSuccess(getProduct);
1479                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1480                 expectedProduct.setUniqueId(product.getUniqueId());
1481                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1482                 expectedProduct.setTags(product.getTags());
1483                 expectedProduct.setVersion(product.getVersion());
1484                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1485                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1486                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1487                                 ComponentOperationEnum.UPDATE_COMPONENT);
1488         }
1489
1490         @Test // (enabled=false)
1491         public void updateProductTagsNameValidationProductNameIsNotInTag() throws Exception {
1492                 createProducrByPSAndCheckIn();
1493                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1494                                 LifeCycleStatesEnum.CHECKOUT);
1495                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1496                 productReqDetails.setUniqueId(product.getUniqueId());
1497                 productReqDetails.setUUID(product.getUUID());
1498                 productReqDetails.setTags(Arrays.asList("Abc"));
1499                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1500                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1501                                 updateProduct.getErrorCode().intValue());
1502                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_INVALID_TAGS_NO_COMP_NAME.name(),
1503                                 new ArrayList<String>(), updateProduct.getResponse());
1504         }
1505
1506         @Test // (enabled=false)
1507         public void createProductSingleTagMaxLength() throws Exception {
1508                 createProducrByPSAndCheckIn();
1509                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1510                                 LifeCycleStatesEnum.CHECKOUT);
1511                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1512                 productReqDetails.setUniqueId(product.getUniqueId());
1513                 productReqDetails.setUUID(product.getUUID());
1514                 productReqDetails.setTags(
1515                                 Arrays.asList(productReqDetails.getName(), "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345678"));
1516                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1517                 ProductRestUtils.checkSuccess(updateProduct);
1518                 // Get Product and verify that metadata change
1519                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1520                                 productManager1.getUserId());
1521                 ProductRestUtils.checkSuccess(getProduct);
1522                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1523                 expectedProduct.setUniqueId(product.getUniqueId());
1524                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1525                 expectedProduct.setTags(productReqDetails.getTags());
1526                 expectedProduct.setVersion(product.getVersion());
1527                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1528                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1529                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1530                                 ComponentOperationEnum.UPDATE_COMPONENT);
1531         }
1532
1533         @Test // (enabled=false)
1534         public void updateProductSingleTagExceedMaxLength() throws Exception {
1535                 createProducrByPSAndCheckIn();
1536                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1537                                 LifeCycleStatesEnum.CHECKOUT);
1538                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1539                 productReqDetails.setUniqueId(product.getUniqueId());
1540                 productReqDetails.setUUID(product.getUUID());
1541                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName(),
1542                                 "123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"));
1543                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1544                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1545                                 updateProduct.getErrorCode().intValue());
1546                 ArrayList<String> varibales = new ArrayList<String>();
1547                 varibales.add("1024");
1548                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_SINGLE_TAG_EXCEED_LIMIT.name(), varibales,
1549                                 updateProduct.getResponse());
1550                 // Get Product and verify that metadata didn't change
1551                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1552                                 productManager1.getUserId());
1553                 ProductRestUtils.checkSuccess(getProduct);
1554                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1555                 expectedProduct.setUniqueId(product.getUniqueId());
1556                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1557                 expectedProduct.setVersion(product.getVersion());
1558                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1559                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1560                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1561                                 ComponentOperationEnum.UPDATE_COMPONENT);
1562         }
1563
1564         @Test // (enabled=false)
1565         public void updateProductAllTagsMaxLength() throws Exception {
1566                 createProducrByPSAndCheckIn();
1567                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1568                                 LifeCycleStatesEnum.CHECKOUT);
1569                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1570                 productReqDetails.setUniqueId(product.getUniqueId());
1571                 productReqDetails.setUUID(product.getUUID());
1572                 productReqDetails.setTags(
1573                                 Arrays.asList(productReqDetails.getName(), "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345601",
1574                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345602",
1575                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345603",
1576                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345604",
1577                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345605",
1578                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345606",
1579                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345607"));
1580                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1581                 ProductRestUtils.checkSuccess(updateProduct);
1582                 // Get Product and verify that metadata change
1583                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1584                                 productManager1.getUserId());
1585                 ProductRestUtils.checkSuccess(getProduct);
1586                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1587                 expectedProduct.setUniqueId(product.getUniqueId());
1588                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1589                 expectedProduct.setTags(productReqDetails.getTags());
1590                 expectedProduct.setVersion(product.getVersion());
1591                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1592                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1593                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1594                                 ComponentOperationEnum.UPDATE_COMPONENT);
1595         }
1596
1597         @Test // (enabled=false)
1598         public void updateProductAllTagsExceedMaxLength() throws Exception {
1599                 createProducrByPSAndCheckIn();
1600                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1601                                 LifeCycleStatesEnum.CHECKOUT);
1602                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1603                 productReqDetails.setUniqueId(product.getUniqueId());
1604                 productReqDetails.setUUID(product.getUUID());
1605                 productReqDetails.setTags(
1606                                 Arrays.asList(productReqDetails.getName(), "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345601",
1607                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345602",
1608                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345603",
1609                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345604",
1610                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345605",
1611                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345606",
1612                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345607",
1613                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345608",
1614                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh1234569",
1615                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345610",
1616                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345611",
1617                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345612",
1618                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345613",
1619                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345614",
1620                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345615",
1621                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345616",
1622                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345617",
1623                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345618",
1624                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345619",
1625                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh123456"));
1626                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1627                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1628                                 updateProduct.getErrorCode().intValue());
1629                 ArrayList<String> varibales = new ArrayList<String>();
1630                 varibales.add("1024");
1631                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_TAGS_EXCEED_LIMIT.name(), varibales,
1632                                 updateProduct.getResponse());
1633                 // Get Product and verify that metadata didn't change
1634                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1635                                 productManager1.getUserId());
1636                 ProductRestUtils.checkSuccess(getProduct);
1637                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1638                 expectedProduct.setUniqueId(product.getUniqueId());
1639                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1640                 expectedProduct.setVersion(product.getVersion());
1641                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1642                                 ComponentOperationEnum.UPDATE_COMPONENT);
1643         }
1644
1645         @Test // (enabled=false)
1646         public void updateProductTagsDuplicateTagRemoved() throws Exception {
1647                 createProducrByPSAndCheckIn();
1648                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1649                                 LifeCycleStatesEnum.CHECKOUT);
1650                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1651                 productReqDetails.setUniqueId(product.getUniqueId());
1652                 productReqDetails.setUUID(product.getUUID());
1653                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName(), "KoKo", "KoKo"));
1654                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1655                 ProductRestUtils.checkSuccess(updateProduct);
1656                 // Get Product and verify that metadata updated
1657                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1658                                 productManager1.getUserId());
1659                 ProductRestUtils.checkSuccess(getProduct);
1660                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1661                 expectedProduct.setUniqueId(product.getUniqueId());
1662                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1663                 expectedProduct.setTags(Arrays.asList(productReqDetails.getName(), "KoKo"));
1664                 expectedProduct.setVersion(product.getVersion());
1665                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1666                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1667                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1668                                 ComponentOperationEnum.UPDATE_COMPONENT);
1669         }
1670
1671         @Test // (enabled=false)
1672         public void updateProductContactsIsEmpty() throws Exception {
1673                 createProducrByPSAndCheckIn();
1674                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1675                                 LifeCycleStatesEnum.CHECKOUT);
1676                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1677                 productReqDetails.setUniqueId(product.getUniqueId());
1678                 productReqDetails.setUUID(product.getUUID());
1679                 productReqDetails.setContacts(Arrays.asList(""));
1680                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1681                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1682                                 updateProduct.getErrorCode().intValue());
1683                 ArrayList<String> varibales = new ArrayList<String>();
1684                 varibales.add(COMPONENT_TYPE);
1685                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_INVALID_CONTACT.name(), varibales,
1686                                 updateProduct.getResponse());
1687                 // Get Product and verify that metadata didn't change
1688                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1689                                 productManager1.getUserId());
1690                 ProductRestUtils.checkSuccess(getProduct);
1691                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1692                 expectedProduct.setUniqueId(product.getUniqueId());
1693                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1694                 expectedProduct.setVersion(product.getVersion());
1695                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1696                                 ComponentOperationEnum.UPDATE_COMPONENT);
1697         }
1698
1699         @Test // (enabled=false)
1700         public void updateProductContactsIsNull() throws Exception {
1701                 createProducrByPSAndCheckIn();
1702                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1703                                 LifeCycleStatesEnum.CHECKOUT);
1704                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1705                 productReqDetails.setUniqueId(product.getUniqueId());
1706                 productReqDetails.setUUID(product.getUUID());
1707                 productReqDetails.setContacts(null);
1708                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1709                 ProductRestUtils.checkSuccess(updateProduct);
1710                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1711                                 productManager1.getUserId());
1712                 ProductRestUtils.checkSuccess(getProduct);
1713                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1714                 expectedProduct.setUniqueId(product.getUniqueId());
1715                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1716                 expectedProduct.setVersion(product.getVersion());
1717                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1718                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1719                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1720                                 ComponentOperationEnum.UPDATE_COMPONENT);
1721         }
1722
1723         @Test // (enabled=false)
1724         public void updateProductContactsInvalidFormat() throws Exception {
1725                 createProducrByPSAndCheckIn();
1726                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1727                                 LifeCycleStatesEnum.CHECKOUT);
1728                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1729                 productReqDetails.setUniqueId(product.getUniqueId());
1730                 productReqDetails.setUUID(product.getUUID());
1731                 productReqDetails.setContacts(Arrays.asList("bt750345"));
1732                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1733                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1734                                 updateProduct.getErrorCode().intValue());
1735                 ArrayList<String> varibales = new ArrayList<String>();
1736                 varibales.add(COMPONENT_TYPE);
1737                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_INVALID_CONTACT.name(), varibales,
1738                                 updateProduct.getResponse());
1739                 // Get Product and verify that metadata didn't change
1740                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1741                                 productManager1.getUserId());
1742                 ProductRestUtils.checkSuccess(getProduct);
1743                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1744                 expectedProduct.setUniqueId(product.getUniqueId());
1745                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1746                 expectedProduct.setVersion(product.getVersion());
1747                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1748                                 ComponentOperationEnum.UPDATE_COMPONENT);
1749         }
1750
1751         @Test // (enabled=false)
1752         public void updateProductConvertContactsToLowerCase() throws Exception {
1753                 createProducrByPSAndCheckIn();
1754                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1755                                 LifeCycleStatesEnum.CHECKOUT);
1756                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1757                 productReqDetails.setUniqueId(product.getUniqueId());
1758                 productReqDetails.setUUID(product.getUUID());
1759                 productReqDetails.setContacts(Arrays.asList(productManager2.getUserId().toUpperCase()));
1760                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1761                 ProductRestUtils.checkSuccess(updateProduct);
1762                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1763                                 productManager1.getUserId());
1764                 ProductRestUtils.checkSuccess(getProduct);
1765                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1766                 expectedProduct.setUniqueId(product.getUniqueId());
1767                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1768                 expectedProduct.setVersion(product.getVersion());
1769                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1770                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1771                 expectedProduct
1772                                 .setContacts(Arrays.asList(productManager2.getUserId().toLowerCase(), productManager1.getUserId()));
1773                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1774                                 ComponentOperationEnum.UPDATE_COMPONENT);
1775         }
1776
1777         @Test // (enabled=false)
1778         public void updateProductContactsNotAllowedAsdcUsers() throws Exception {
1779                 createProducrByPSAndCheckIn();
1780                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1781                                 LifeCycleStatesEnum.CHECKOUT);
1782                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1783                 productReqDetails.setUniqueId(product.getUniqueId());
1784                 productReqDetails.setUUID(product.getUUID());
1785                 productReqDetails.setContacts(Arrays.asList(productStrategistUser1.getUserId()));
1786                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1787                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1788                                 updateProduct.getErrorCode().intValue());
1789                 ArrayList<String> varibales = new ArrayList<String>();
1790                 varibales.add(productStrategistUser1.getUserId());
1791                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_PRODUCT_CONTACT.name(), varibales,
1792                                 updateProduct.getResponse());
1793                 // Get Product and verify that metadata didn't change
1794                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1795                                 productManager1.getUserId());
1796                 ProductRestUtils.checkSuccess(getProduct);
1797                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1798                 expectedProduct.setUniqueId(product.getUniqueId());
1799                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1800                 expectedProduct.setVersion(product.getVersion());
1801                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1802                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1803                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1804                                 ComponentOperationEnum.UPDATE_COMPONENT);
1805         }
1806
1807         @Test // (enabled=false)
1808         public void updateProductContactsNotAsdcUser() throws Exception {
1809                 createProducrByPSAndCheckIn();
1810                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1811                                 LifeCycleStatesEnum.CHECKOUT);
1812                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1813                 productReqDetails.setUniqueId(product.getUniqueId());
1814                 productReqDetails.setUUID(product.getUUID());
1815                 String nonAsdcUserUserId = "bt567h";
1816                 productReqDetails.setContacts(Arrays.asList(nonAsdcUserUserId));
1817                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1818                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1819                                 updateProduct.getErrorCode().intValue());
1820                 ArrayList<String> varibales = new ArrayList<String>();
1821                 varibales.add(nonAsdcUserUserId);
1822                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_PRODUCT_CONTACT.name(), varibales,
1823                                 updateProduct.getResponse());
1824                 // Get Product and verify that metadata didn't change
1825                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1826                                 productManager1.getUserId());
1827                 ProductRestUtils.checkSuccess(getProduct);
1828                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1829                 expectedProduct.setUniqueId(product.getUniqueId());
1830                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1831                 expectedProduct.setVersion(product.getVersion());
1832                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1833                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1834                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1835                                 ComponentOperationEnum.UPDATE_COMPONENT);
1836         }
1837
1838         @Test // (enabled=false)
1839         public void updateProductProjectCodeIsEmpty() throws Exception {
1840                 createProducrByPSAndCheckIn();
1841                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1842                                 LifeCycleStatesEnum.CHECKOUT);
1843                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1844                 productReqDetails.setUniqueId(product.getUniqueId());
1845                 productReqDetails.setUUID(product.getUUID());
1846                 productReqDetails.setProjectCode("");
1847                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1848                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1849                                 updateProduct.getErrorCode().intValue());
1850                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_PROJECT_CODE.name(), new ArrayList<String>(),
1851                                 updateProduct.getResponse());
1852                 // Get Product and verify that metadata didn't change
1853                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1854                                 productManager1.getUserId());
1855                 ProductRestUtils.checkSuccess(getProduct);
1856                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1857                 expectedProduct.setUniqueId(product.getUniqueId());
1858                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1859                 expectedProduct.setVersion(product.getVersion());
1860                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1861                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1862                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1863                                 ComponentOperationEnum.UPDATE_COMPONENT);
1864         }
1865
1866         @Test // (enabled=false)
1867         public void updateProductProjectCodeIsNull() throws Exception {
1868                 createProducrByPSAndCheckIn();
1869                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1870                                 LifeCycleStatesEnum.CHECKOUT);
1871                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1872                 productReqDetails.setUniqueId(product.getUniqueId());
1873                 productReqDetails.setUUID(product.getUUID());
1874                 productReqDetails.setProjectCode(null);
1875                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1876                 ProductRestUtils.checkSuccess(updateProduct);
1877                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1878                                 productManager1.getUserId());
1879                 ProductRestUtils.checkSuccess(getProduct);
1880                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1881                 expectedProduct.setUniqueId(product.getUniqueId());
1882                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1883                 expectedProduct.setVersion(product.getVersion());
1884                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1885                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1886                 expectedProduct.setProjectCode(product.getProjectCode());
1887                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1888                                 ComponentOperationEnum.UPDATE_COMPONENT);
1889         }
1890
1891         @Test // (enabled=false)
1892         public void updateProductProjectCodeLessThanMinCharacters() throws Exception {
1893                 createProducrByPSAndCheckIn();
1894                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1895                                 LifeCycleStatesEnum.CHECKOUT);
1896                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1897                 productReqDetails.setUniqueId(product.getUniqueId());
1898                 productReqDetails.setUUID(product.getUUID());
1899                 productReqDetails.setProjectCode("9870");
1900                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1901                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1902                                 updateProduct.getErrorCode().intValue());
1903                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_PROJECT_CODE.name(), new ArrayList<String>(),
1904                                 updateProduct.getResponse());
1905                 // Get Product and verify that metadata didn't change
1906                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1907                                 productManager1.getUserId());
1908                 ProductRestUtils.checkSuccess(getProduct);
1909                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1910                 expectedProduct.setUniqueId(product.getUniqueId());
1911                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1912                 expectedProduct.setVersion(product.getVersion());
1913                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1914                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1915                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1916                                 ComponentOperationEnum.UPDATE_COMPONENT);
1917         }
1918
1919         @Test // (enabled=false)
1920         public void updateProductProjectCodeHasnMinCharacters() throws Exception { // min
1921                                                                                                                                                                 // =5
1922                 createProducrByPSAndCheckIn();
1923                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1924                                 LifeCycleStatesEnum.CHECKOUT);
1925                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1926                 productReqDetails.setUniqueId(product.getUniqueId());
1927                 productReqDetails.setUUID(product.getUUID());
1928                 productReqDetails.setProjectCode("98700");
1929                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1930                 ProductRestUtils.checkSuccess(updateProduct);
1931                 // Get Product and verify that metadata didn't change
1932                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1933                                 productManager1.getUserId());
1934                 ProductRestUtils.checkSuccess(getProduct);
1935                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1936                 expectedProduct.setUniqueId(product.getUniqueId());
1937                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1938                 expectedProduct.setVersion(product.getVersion());
1939                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1940                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1941                 expectedProduct.setProjectCode(productReqDetails.getProjectCode());
1942                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1943                                 ComponentOperationEnum.UPDATE_COMPONENT);
1944         }
1945
1946         @Test // (enabled=false)
1947         public void updateProductProjectCodeHasnMaxCharacters() throws Exception {
1948                 createProducrByPSAndCheckIn();
1949                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1950                                 LifeCycleStatesEnum.CHECKOUT);
1951                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1952                 productReqDetails.setUniqueId(product.getUniqueId());
1953                 productReqDetails.setUUID(product.getUUID());
1954                 productReqDetails.setProjectCode("1234567890");
1955                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1956                 ProductRestUtils.checkSuccess(updateProduct);
1957                 // Get Product and verify that metadata didn't change
1958                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1959                                 productManager1.getUserId());
1960                 ProductRestUtils.checkSuccess(getProduct);
1961                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1962                 expectedProduct.setUniqueId(product.getUniqueId());
1963                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1964                 expectedProduct.setVersion(product.getVersion());
1965                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1966                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1967                 expectedProduct.setProjectCode(productReqDetails.getProjectCode());
1968                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1969                                 ComponentOperationEnum.UPDATE_COMPONENT);
1970         }
1971
1972         @Test // (enabled=false)
1973         public void updateProductProjectCodeExceedMaxCharacters() throws Exception {// Max
1974                 // =10
1975                 createProducrByPSAndCheckIn();
1976                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
1977                                 LifeCycleStatesEnum.CHECKOUT);
1978                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
1979                 productReqDetails.setUniqueId(product.getUniqueId());
1980                 productReqDetails.setUUID(product.getUUID());
1981                 productReqDetails.setProjectCode("12345678901");
1982                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
1983                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1984                                 updateProduct.getErrorCode().intValue());
1985                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_PROJECT_CODE.name(), new ArrayList<String>(),
1986                                 updateProduct.getResponse());
1987                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1988                                 productManager1.getUserId());
1989                 ProductRestUtils.checkSuccess(getProduct);
1990                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1991                 expectedProduct.setUniqueId(product.getUniqueId());
1992                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
1993                 expectedProduct.setVersion(product.getVersion());
1994                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
1995                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
1996                 expectedProduct.setProjectCode(product.getProjectCode());
1997                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1998                                 ComponentOperationEnum.UPDATE_COMPONENT);
1999         }
2000
2001         @Test // (enabled=false)
2002         public void updateProductProjectCodeIsNotNumeric() throws Exception {
2003                 // Max =10
2004                 createProducrByPSAndCheckIn();
2005                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2006                                 LifeCycleStatesEnum.CHECKOUT);
2007                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2008                 productReqDetails.setUniqueId(product.getUniqueId());
2009                 productReqDetails.setUUID(product.getUUID());
2010                 productReqDetails.setProjectCode("1234a");
2011                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2012                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
2013                                 updateProduct.getErrorCode().intValue());
2014                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_PROJECT_CODE.name(), new ArrayList<String>(),
2015                                 updateProduct.getResponse());
2016                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
2017                                 productManager1.getUserId());
2018                 ProductRestUtils.checkSuccess(getProduct);
2019                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2020                 expectedProduct.setUniqueId(product.getUniqueId());
2021                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
2022                 expectedProduct.setVersion(product.getVersion());
2023                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
2024                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
2025                 expectedProduct.setProjectCode(product.getProjectCode());
2026                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2027                                 ComponentOperationEnum.UPDATE_COMPONENT);
2028         }
2029
2030         @Test // (enabled=false)
2031         public void updateProductIconIsEmpty() throws Exception {
2032                 createProducrByPSAndCheckIn();
2033                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2034                                 LifeCycleStatesEnum.CHECKOUT);
2035                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2036                 productReqDetails.setUniqueId(product.getUniqueId());
2037                 productReqDetails.setUUID(product.getUUID());
2038                 productReqDetails.setIcon("");
2039                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2040                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
2041                                 updateProduct.getErrorCode().intValue());
2042                 ArrayList<String> variables = new ArrayList<String>();
2043                 variables.add(COMPONENT_TYPE);
2044                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_MISSING_ICON.name(), variables,
2045                                 updateProduct.getResponse());
2046                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
2047                                 productManager1.getUserId());
2048                 ProductRestUtils.checkSuccess(getProduct);
2049                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2050                 expectedProduct.setUniqueId(product.getUniqueId());
2051                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
2052                 expectedProduct.setVersion(product.getVersion());
2053                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
2054                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
2055                 expectedProduct.setIcon(product.getIcon());
2056                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2057                                 ComponentOperationEnum.UPDATE_COMPONENT);
2058         }
2059
2060         @Test // (enabled=false)
2061         public void updateProductIconIsNull() throws Exception {
2062                 createProducrByPSAndCheckIn();
2063                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2064                                 LifeCycleStatesEnum.CHECKOUT);
2065                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2066                 productReqDetails.setUniqueId(product.getUniqueId());
2067                 productReqDetails.setUUID(product.getUUID());
2068                 productReqDetails.setIcon(null);
2069                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2070                 ProductRestUtils.checkSuccess(updateProduct);
2071                 // Get Product and verify that metadata didn't change
2072                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
2073                                 productManager1.getUserId());
2074                 ProductRestUtils.checkSuccess(getProduct);
2075                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2076                 expectedProduct.setUniqueId(product.getUniqueId());
2077                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
2078                 expectedProduct.setVersion(product.getVersion());
2079                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
2080                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
2081                 expectedProduct.setIcon(product.getIcon());
2082                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2083                                 ComponentOperationEnum.UPDATE_COMPONENT);
2084         }
2085
2086         @Test // (enabled=false)
2087         public void updateProductIconMaxLength() throws Exception {
2088                 createProducrByPSAndCheckIn();
2089                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2090                                 LifeCycleStatesEnum.CHECKOUT);
2091                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2092                 productReqDetails.setUniqueId(product.getUniqueId());
2093                 productReqDetails.setUUID(product.getUUID());
2094                 productReqDetails.setIcon("A_a-1-2--b__BB1234567890A"); // Max length =
2095                                                                                                                                 // 25
2096                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2097                 ProductRestUtils.checkSuccess(updateProduct);
2098                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
2099                                 productManager1.getUserId());
2100                 ProductRestUtils.checkSuccess(getProduct);
2101                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2102                 expectedProduct.setUniqueId(product.getUniqueId());
2103                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
2104                 expectedProduct.setVersion(product.getVersion());
2105                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
2106                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
2107                 expectedProduct.setIcon(productReqDetails.getIcon());
2108                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2109                                 ComponentOperationEnum.UPDATE_COMPONENT);
2110         }
2111
2112         @Test // (enabled=false)
2113         public void updateProductIconExceedMaxLength() throws Exception {
2114                 createProducrByPSAndCheckIn();
2115                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2116                                 LifeCycleStatesEnum.CHECKOUT);
2117                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2118                 productReqDetails.setUniqueId(product.getUniqueId());
2119                 productReqDetails.setUUID(product.getUUID());
2120                 productReqDetails.setIcon("A_a-1-2--b__BB1234567890A_");
2121                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2122                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
2123                                 updateProduct.getErrorCode().intValue());
2124                 ArrayList<String> variables = new ArrayList<String>();
2125                 variables.add(COMPONENT_TYPE);
2126                 variables.add("25");
2127                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_ICON_EXCEEDS_LIMIT.name(), variables,
2128                                 updateProduct.getResponse());
2129                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
2130                                 productManager1.getUserId());
2131                 ProductRestUtils.checkSuccess(getProduct);
2132                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2133                 expectedProduct.setUniqueId(product.getUniqueId());
2134                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
2135                 expectedProduct.setVersion(product.getVersion());
2136                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
2137                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
2138                 expectedProduct.setIcon(product.getIcon());
2139                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2140                                 ComponentOperationEnum.UPDATE_COMPONENT);
2141         }
2142
2143         @Test // (enabled=false)
2144         public void updateProductIconInValidCharacters() throws Exception {
2145                 createProducrByPSAndCheckIn();
2146                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2147                                 LifeCycleStatesEnum.CHECKOUT);
2148                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2149                 productReqDetails.setUniqueId(product.getUniqueId());
2150                 productReqDetails.setUUID(product.getUUID());
2151                 String icon = "asdfg"; // Allowed characters [a-zA-Z0-9], dash (‘-‘),
2152                                                                 // underscore (‘_’).
2153                 char invalidChars[] = { '~', '!', '$', '%', '^', '*', '(', ')', '"', '{', '}', '[', ']', '?', '>', '<', '/',
2154                                 '|', '\\', ',' };
2155                 RestResponse updateProduct;
2156                 for (int i = 0; i < invalidChars.length; i++) {
2157                         productReqDetails.setIcon(icon + invalidChars[i]);
2158                         updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2159                         assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
2160                                         updateProduct.getErrorCode().intValue());
2161                         ArrayList<String> variables = new ArrayList<String>();
2162                         variables.add(COMPONENT_TYPE);
2163                         ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_INVALID_ICON.name(), variables,
2164                                         updateProduct.getResponse());
2165                 }
2166                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
2167                                 productManager1.getUserId());
2168                 ProductRestUtils.checkSuccess(getProduct);
2169                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2170                 expectedProduct.setUniqueId(product.getUniqueId());
2171                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
2172                 expectedProduct.setVersion(product.getVersion());
2173                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
2174                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
2175                 expectedProduct.setIcon(product.getIcon());
2176                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2177                                 ComponentOperationEnum.UPDATE_COMPONENT);
2178         }
2179
2180         @Test // (enabled=false)
2181         public void updateProductIsActiveIsEmpty() throws Exception {
2182                 createProducrByPSAndCheckIn();
2183                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2184                                 LifeCycleStatesEnum.CHECKOUT);
2185                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2186                 productReqDetails.setUniqueId(product.getUniqueId());
2187                 productReqDetails.setUUID(product.getUUID());
2188                 productReqDetails.setActive("");
2189                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2190                 ProductRestUtils.checkSuccess(updateProduct);
2191                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
2192                                 productManager1.getUserId());
2193                 ProductRestUtils.checkSuccess(getProduct);
2194                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2195                 expectedProduct.setUniqueId(product.getUniqueId());
2196                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
2197                 expectedProduct.setVersion(product.getVersion());
2198                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
2199                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
2200                 expectedProduct.setIsActive(false);
2201                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2202                                 ComponentOperationEnum.UPDATE_COMPONENT);
2203         }
2204
2205         @Test // (enabled=false)
2206         public void updateProductIsActiveIsTrue() throws Exception {
2207                 createProducrByPSAndCheckIn();
2208                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2209                                 LifeCycleStatesEnum.CHECKOUT);
2210                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2211                 productReqDetails.setUniqueId(product.getUniqueId());
2212                 productReqDetails.setUUID(product.getUUID());
2213                 productReqDetails.setActive("true");
2214                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2215                 ProductRestUtils.checkSuccess(updateProduct);
2216                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
2217                                 productManager1.getUserId());
2218                 ProductRestUtils.checkSuccess(getProduct);
2219                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2220                 expectedProduct.setUniqueId(product.getUniqueId());
2221                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
2222                 expectedProduct.setVersion(product.getVersion());
2223                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
2224                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
2225                 expectedProduct.setIsActive(true);
2226                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2227                                 ComponentOperationEnum.UPDATE_COMPONENT);
2228         }
2229
2230         @Test // (enabled=false)
2231         public void updateProductIsActiveIsNull() throws Exception {
2232                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct(defaultCategories);
2233                 productReqDetails.setActive("true");
2234                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
2235                 ProductRestUtils.checkCreateResponse(createProduct);
2236                 Product product = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2237                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2238                                 LifeCycleStatesEnum.CHECKIN);
2239                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2240                 changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2241                                 LifeCycleStatesEnum.CHECKOUT);
2242                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2243                 productReqDetails.setUniqueId(product.getUniqueId());
2244                 productReqDetails.setUUID(product.getUUID());
2245                 productReqDetails.setActive(null);
2246                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2247                 ProductRestUtils.checkSuccess(updateProduct);
2248                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
2249                                 productManager1.getUserId());
2250                 ProductRestUtils.checkSuccess(getProduct);
2251                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2252                 expectedProduct.setUniqueId(product.getUniqueId());
2253                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
2254                 expectedProduct.setVersion(product.getVersion());
2255                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
2256                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
2257                 expectedProduct.setIsActive(true);
2258                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2259                                 ComponentOperationEnum.UPDATE_COMPONENT);
2260         }
2261
2262         @Test // (enabled=false)
2263         public void updateProductIsActiveIsFalse() throws Exception {
2264                 createProducrByPSAndCheckIn();
2265                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2266                                 LifeCycleStatesEnum.CHECKOUT);
2267                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2268                 productReqDetails.setUniqueId(product.getUniqueId());
2269                 productReqDetails.setUUID(product.getUUID());
2270                 productReqDetails.setActive("false");
2271                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2272                 ProductRestUtils.checkSuccess(updateProduct);
2273                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
2274                                 productManager1.getUserId());
2275                 ProductRestUtils.checkSuccess(getProduct);
2276                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2277                 expectedProduct.setUniqueId(product.getUniqueId());
2278                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
2279                 expectedProduct.setVersion(product.getVersion());
2280                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
2281                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
2282                 expectedProduct.setIsActive(false);
2283                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2284                                 ComponentOperationEnum.UPDATE_COMPONENT);
2285         }
2286
2287         @Test // (enabled=false)
2288         public void updateProductIsActiveHasInvalidValue() throws Exception {
2289                 createProducrByPSAndCheckIn();
2290                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2291                                 LifeCycleStatesEnum.CHECKOUT);
2292                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2293                 productReqDetails.setUniqueId(product.getUniqueId());
2294                 productReqDetails.setUUID(product.getUUID());
2295                 productReqDetails.setActive("eeeee");
2296                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2297                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
2298                                 updateProduct.getErrorCode().intValue());
2299                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_CONTENT.name(), new ArrayList<String>(),
2300                                 updateProduct.getResponse());
2301                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
2302                                 updateProduct.getErrorCode().intValue());
2303                 RestResponse getProduct = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
2304                                 productManager1.getUserId());
2305                 ProductRestUtils.checkSuccess(getProduct);
2306                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2307                 expectedProduct.setUniqueId(product.getUniqueId());
2308                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProduct.getResponse(), Product.class);
2309                 expectedProduct.setVersion(product.getVersion());
2310                 expectedProduct.setLastUpdaterUserId(productManager1.getUserId());
2311                 expectedProduct.setLastUpdaterFullName(productManager1.getFullName());
2312                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2313                                 ComponentOperationEnum.UPDATE_COMPONENT);
2314         }
2315
2316         @Test // (enabled=false)
2317         public void updateProductAssociations() throws Exception {
2318                 createProducrByPSAndCheckIn();
2319                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2320                                 LifeCycleStatesEnum.CHECKOUT);
2321                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2322                 productReqDetails.setUniqueId(product.getUniqueId());
2323                 productReqDetails.setUUID(product.getUUID());
2324                 List<CategoryDefinition> addSecondGroupingToDefaultCategory = addSecondGroupingToDefaultCategory();
2325                 productReqDetails.setCategories(addSecondGroupingToDefaultCategory);
2326                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2327                 ProductRestUtils.checkSuccess(updateProduct);
2328                 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
2329                 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
2330                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
2331                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
2332                 expectedProduct.setUUID(product.getUUID());
2333                 expectedProduct.setInvariantUUID(product.getInvariantUUID());
2334                 expectedProduct.setCategories(productReqDetails.getCategories());
2335                 expectedProduct.setNormalizedName(productReqDetails.getName().toLowerCase());
2336                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2337                                 ComponentOperationEnum.UPDATE_COMPONENT);
2338         }
2339
2340         @Test // (enabled=false)
2341         public void updateProductAssociations02() throws Exception {
2342                 List<CategoryDefinition> addSecondGroupingToDefaultCategory = addSecondGroupingToDefaultCategory(); // Category1->Subcategory1->[Grouping1,
2343                                                                                                                                                                                                                         // Grouping11]
2344                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct(addSecondGroupingToDefaultCategory);
2345                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
2346                 ProductRestUtils.checkCreateResponse(createProduct);
2347                 Product product = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2348                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2349                                 LifeCycleStatesEnum.CHECKIN);
2350                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2351                 changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2352                                 LifeCycleStatesEnum.CHECKOUT);
2353                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2354                 productReqDetails.setUniqueId(product.getUniqueId());
2355                 productReqDetails.setUUID(product.getUUID());
2356                 List<CategoryDefinition> defaultCategory = addSubcategoryAndGroupingToDefaultCategory(); // Category1->[Subcategory1->[Grouping1,
2357                                                                                                                                                                                                         // Grouping11],Subcategory2->[Grouping12]]
2358                 productReqDetails.setCategories(defaultCategory);
2359                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2360                 ProductRestUtils.checkSuccess(updateProduct);
2361                 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
2362                 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
2363                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
2364                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
2365                 expectedProduct.setUUID(product.getUUID());
2366                 expectedProduct.setInvariantUUID(product.getInvariantUUID());
2367                 expectedProduct.setCategories(productReqDetails.getCategories());
2368                 expectedProduct.setNormalizedName(productReqDetails.getName().toLowerCase());
2369                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2370                                 ComponentOperationEnum.UPDATE_COMPONENT);
2371         }
2372
2373         @Test // (enabled=false)
2374         public void updateProductRemoveAllAssociations() throws Exception {
2375                 createProducrByPSAndCheckIn();
2376                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2377                                 LifeCycleStatesEnum.CHECKOUT);
2378                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2379                 productReqDetails.setUniqueId(product.getUniqueId());
2380                 productReqDetails.setUUID(product.getUUID());
2381                 List<CategoryDefinition> defaultCategory = new ArrayList<CategoryDefinition>();
2382                 productReqDetails.setCategories(defaultCategory);
2383                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2384                 ProductRestUtils.checkSuccess(updateProduct);
2385                 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
2386                 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
2387                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
2388                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
2389                 expectedProduct.setUUID(product.getUUID());
2390                 expectedProduct.setInvariantUUID(product.getInvariantUUID());
2391                 expectedProduct.setCategories(productReqDetails.getCategories());
2392                 expectedProduct.setNormalizedName(productReqDetails.getName().toLowerCase());
2393                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2394                                 ComponentOperationEnum.UPDATE_COMPONENT);
2395         }
2396
2397         @Test // (enabled=false)
2398         public void updateProductAssociationsCategotyIsNull() throws Exception {
2399                 createProducrByPSAndCheckIn();
2400                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2401                                 LifeCycleStatesEnum.CHECKOUT);
2402                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2403                 productReqDetails.setUniqueId(product.getUniqueId());
2404                 productReqDetails.setUUID(product.getUUID());
2405                 productReqDetails.setCategories(null);// product categories will not be
2406                                                                                                 // updated
2407                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2408                 ProductRestUtils.checkSuccess(updateProduct);
2409                 productReqDetails.setLastUpdaterUserId(productManager1.getUserId());
2410                 productReqDetails.setLastUpdaterFullName(productManager1.getFullName());
2411                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(updateProduct.getResponse(), Product.class);
2412                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "0.2", productManager1);
2413                 expectedProduct.setUUID(product.getUUID());
2414                 expectedProduct.setInvariantUUID(product.getInvariantUUID());
2415                 expectedProduct.setCategories(product.getCategories());
2416                 expectedProduct.setNormalizedName(productReqDetails.getName().toLowerCase());
2417                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2418                                 ComponentOperationEnum.UPDATE_COMPONENT);
2419         }
2420
2421         ////////////////////////////////////////////////////////////////////////
2422
2423         private void createProductWithCategories(List<CategoryDefinition> categoryDefinitions) throws Exception {
2424                 ProductReqDetails productReqDetails = (categoryDefinitions != null
2425                                 ? ElementFactory.getDefaultProduct(categoryDefinitions) : ElementFactory.getDefaultProduct());
2426                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
2427                 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_CREATED,
2428                                 createProduct.getErrorCode().intValue());
2429                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2430                 String actualUuid = ResponseParser.getUuidFromResponse(createProduct);
2431                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, INITIAL_PRODUCT_VERSION,
2432                                 productManager1);
2433                 String normalizedNameFomJsonResponse = ResponseParser.getValueFromJsonResponse(createProduct.getResponse(),
2434                                 "normalizedName");
2435                 expectedProduct.setNormalizedName(normalizedNameFomJsonResponse);
2436                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
2437                                 ComponentOperationEnum.CREATE_COMPONENT);
2438                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
2439                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
2440                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, actualUuid);
2441                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
2442         }
2443
2444         private void createProducrByPSAndCheckIn() throws Exception {
2445                 productReqDetails = ElementFactory.getDefaultProduct(defaultCategories);
2446                 createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
2447                 ProductRestUtils.checkCreateResponse(createProduct);
2448                 product = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
2449                 RestResponse changeProductLifeCycle = ProductRestUtils.changeProductLifeCycle(product, productManager1,
2450                                 LifeCycleStatesEnum.CHECKIN);
2451                 ProductRestUtils.checkSuccess(changeProductLifeCycle);
2452         }
2453
2454         @Test
2455         public void checkInvariantUuidIsImmutable() throws Exception {
2456                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
2457                 String invariantUuidDefinedByUser = "!!!!!!!!!!!!!!!!!!!!!!!!";
2458                 productReqDetails.setInvariantUUID(invariantUuidDefinedByUser);
2459                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
2460                 BaseRestUtils.checkStatusCode(createProduct, "create request failed", false, 201);
2461                 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_CREATED,
2462                                 createProduct.getErrorCode().intValue());
2463                 Product ProductCreation = ResponseParser.convertProductResponseToJavaObject(createProduct.getResponse());
2464                 String invariantUUIDcreation = ProductCreation.getInvariantUUID();
2465
2466                 // validate get response
2467                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
2468                                 productManager1.getUserId());
2469                 BaseRestUtils.checkSuccess(getProductRes);
2470                 Product productGetting = ResponseParser.convertProductResponseToJavaObject(getProductRes.getResponse());
2471                 String invariantUUIDgetting = productGetting.getInvariantUUID();
2472                 assertEquals(invariantUUIDcreation, invariantUUIDgetting);
2473
2474                 // Update Product with new invariant UUID
2475                 RestResponse restResponseUpdate = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2476                 BaseRestUtils.checkSuccess(restResponseUpdate);
2477                 Product updatedProduct = ResponseParser.convertProductResponseToJavaObject(restResponseUpdate.getResponse());
2478                 String invariantUUIDupdating = updatedProduct.getInvariantUUID();
2479                 assertEquals(invariantUUIDcreation, invariantUUIDupdating);
2480
2481                 // Do checkin
2482                 RestResponse restResponseCheckin = LifecycleRestUtils.changeProductState(productReqDetails, productManager1,
2483                                 LifeCycleStatesEnum.CHECKIN);
2484                 BaseRestUtils.checkSuccess(restResponseCheckin);
2485                 Product checkinProduct = ResponseParser.convertProductResponseToJavaObject(restResponseCheckin.getResponse());
2486                 String invariantUUIDcheckin = checkinProduct.getInvariantUUID();
2487                 String version = checkinProduct.getVersion();
2488                 assertEquals(invariantUUIDcreation, invariantUUIDcheckin);
2489                 assertEquals(version, "0.1");
2490
2491                 // Do checkout
2492                 RestResponse restResponseCheckout = LifecycleRestUtils.changeProductState(productReqDetails, productManager1,
2493                                 LifeCycleStatesEnum.CHECKOUT);
2494                 BaseRestUtils.checkSuccess(restResponseCheckout);
2495                 Product checkoutProduct = ResponseParser.convertProductResponseToJavaObject(restResponseCheckout.getResponse());
2496                 String invariantUUIDcheckout = checkoutProduct.getInvariantUUID();
2497                 version = checkoutProduct.getVersion();
2498                 assertEquals(invariantUUIDcreation, invariantUUIDcheckout);
2499                 assertEquals(version, "0.2");
2500
2501         }
2502
2503         // US672129 Benny
2504         private void getProductValidateInvariantUuid(String productUniqueId, String invariantUUIDcreation)
2505                         throws Exception {
2506                 RestResponse getProduct = ProductRestUtils.getProduct(productUniqueId,
2507                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER).getUserId());
2508                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, getProduct.getErrorCode().intValue());
2509                 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(getProduct));
2510         }
2511
2512         @Test // invariantUUID generated when the component is created and never
2513                         // changed
2514         public void productInvariantUuid() throws Exception {
2515                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
2516                 String invariantUuidDefinedByUser = "12345";
2517                 productReqDetails.setInvariantUUID(invariantUuidDefinedByUser);
2518                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
2519                 assertEquals("Check response code after create resource", BaseRestUtils.STATUS_CODE_CREATED,
2520                                 createProduct.getErrorCode().intValue());
2521                 // invariantUUID generated when the component is created and never
2522                 // changed
2523                 String invariantUUIDcreation = ResponseParser.getInvariantUuid(createProduct);
2524                 getProductValidateInvariantUuid(productReqDetails.getUniqueId(), invariantUUIDcreation);
2525                 // Update Product with new invariant UUID
2526                 RestResponse restResponse = ProductRestUtils.updateProduct(productReqDetails, productManager1);
2527                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
2528                 getProductValidateInvariantUuid(productReqDetails.getUniqueId(), invariantUUIDcreation);
2529                 // Checkin
2530                 restResponse = LifecycleRestUtils.changeProductState(productReqDetails, productManager1,
2531                                 LifeCycleStatesEnum.CHECKIN);
2532                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
2533                 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
2534                 getProductValidateInvariantUuid(productReqDetails.getUniqueId(), invariantUUIDcreation);
2535                 // Checkout
2536                 restResponse = LifecycleRestUtils.changeProductState(productReqDetails, productManager1,
2537                                 LifeCycleStatesEnum.CHECKOUT);
2538                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
2539                 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
2540                 getProductValidateInvariantUuid(productReqDetails.getUniqueId(), invariantUUIDcreation);
2541
2542                 // UnDo-CheckOut
2543                 restResponse = LifecycleRestUtils.changeProductState(productReqDetails, productManager1,
2544                                 LifeCycleStatesEnum.UNDOCHECKOUT);
2545                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
2546                 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
2547                 getProductValidateInvariantUuid(productReqDetails.getUniqueId(), invariantUUIDcreation);
2548
2549         }
2550
2551 }