asdc-tests/src/main/java/org/openecomp/sdc/ci/tests/execute/product/ProductCrudTest.java

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