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