test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/product/ProductCreateWithValidationsTest.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 org.json.JSONArray;
  24 import org.json.JSONException;
  25 import org.junit.Rule;
  26 import org.junit.rules.TestName;
  27 import org.openecomp.sdc.be.dao.api.ActionStatus;
  28 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  29 import org.openecomp.sdc.be.model.Product;
  30 import org.openecomp.sdc.be.model.User;
  31 import org.openecomp.sdc.ci.tests.datatypes.ProductReqDetails;
  32 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  33 import org.openecomp.sdc.ci.tests.datatypes.expected.ExpectedProductAudit;
  34 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  35 import org.openecomp.sdc.ci.tests.utils.DbUtils;
  36 import org.openecomp.sdc.ci.tests.utils.general.Convertor;
  37 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  38 import org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils;
  39 import org.openecomp.sdc.ci.tests.utils.rest.ProductRestUtils;
  40 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  41 import org.openecomp.sdc.ci.tests.utils.validation.AuditValidationUtils;
  42 import org.openecomp.sdc.ci.tests.utils.validation.ProductValidationUtils;
  43 import org.openecomp.sdc.common.api.Constants;
  44 import org.testng.annotations.Test;
  45
  46 import java.util.Arrays;
  47
  48 import static org.testng.AssertJUnit.assertEquals;
  49 import static org.testng.AssertJUnit.assertTrue;
  50
  51 public class ProductCreateWithValidationsTest extends ProductBaseTest {
  52         @Rule
  53         public static TestName name = new TestName();
  54
  55         public static String INITIAL_PRODUCT_VERSION = "0.1";
  56         public static String CREATE_AUDIT_ACTION = "Create";
  57         public String normalizedName;
  58
  59         public ProductCreateWithValidationsTest() {
  60                 super(name, ProductCreateWithValidationsTest.class.getName());
  61         }
  62
  63         @Test // (enabled = false)
  64         public void createProductSuccessValidation() throws Exception {
  65                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
  66                 // productReqDetails.setName("CIProduct1");
  67                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
  68                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
  69                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
  70                 ProductRestUtils.checkCreateResponse(createProduct);
  71                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
  72                 compareExpectedAndActualProducts(productReqDetails, createProduct);
  73                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
  74                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
  75                                 productManager1.getUserId());
  76                 ProductRestUtils.checkSuccess(getProductRes);
  77                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
  78                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
  79                                 ComponentOperationEnum.GET_COMPONENT);
  80                 assertEquals(actualProduct.getIsActive(), new Boolean(false));
  81                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
  82                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
  83                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
  84                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
  85         }
  86
  87         @Test
  88         public void createProductNotByPmUser() throws Exception {
  89                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
  90                 // productReqDetails.setName("CIProduct1");
  91                 normalizedName = productReqDetails.getName().toLowerCase();
  92                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productStrategistUser1);
  93                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION,
  94                                 createProduct.getErrorCode().intValue());
  95                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, INITIAL_PRODUCT_VERSION,
  96                                 productStrategistUser1);
  97                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
  98                                 expectedProduct, CREATE_AUDIT_ACTION, productStrategistUser1, ActionStatus.RESTRICTED_OPERATION,
  99                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
 100                 constructFieldsForAuditValidation.setCURR_VERSION("");
 101                 constructFieldsForAuditValidation.setCURR_STATE("");
 102                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 103         }
 104
 105         @Test
 106         public void createProductNotByAsdcUser() throws Exception {
 107                 User nonAsdcUser = ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1);
 108                 nonAsdcUser.setUserId("bt750k");
 109                 nonAsdcUser.setFirstName(null);
 110                 nonAsdcUser.setLastName(null);
 111                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 112                 // productReqDetails.setName("CIProduct1");
 113                 normalizedName = productReqDetails.getName().toLowerCase();
 114                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, nonAsdcUser);
 115                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION,
 116                                 createProduct.getErrorCode().intValue());
 117                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, INITIAL_PRODUCT_VERSION,
 118                                 nonAsdcUser);
 119                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 120                                 expectedProduct, CREATE_AUDIT_ACTION, nonAsdcUser, ActionStatus.RESTRICTED_OPERATION,
 121                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
 122                 constructFieldsForAuditValidation.setCURR_VERSION("");
 123                 constructFieldsForAuditValidation.setCURR_STATE("");
 124                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 125         }
 126
 127         @Test
 128         public void createProductUserIdIsEmpty() throws Exception {
 129                 User nonAsdcUser = ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1);
 130                 nonAsdcUser.setUserId("");
 131                 nonAsdcUser.setFirstName(null);
 132                 nonAsdcUser.setLastName(null);
 133                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 134                 // productReqDetails.setName("CIProduct1");
 135                 normalizedName = productReqDetails.getName().toLowerCase();
 136                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, nonAsdcUser);
 137                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_MISSING_INFORMATION,
 138                                 createProduct.getErrorCode().intValue());
 139                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, INITIAL_PRODUCT_VERSION,
 140                                 nonAsdcUser);
 141                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 142                                 expectedProduct, CREATE_AUDIT_ACTION, nonAsdcUser, ActionStatus.MISSING_INFORMATION,
 143                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
 144                 constructFieldsForAuditValidation.setCURR_VERSION("");
 145                 constructFieldsForAuditValidation.setCURR_STATE("");
 146                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 147         }
 148
 149         @Test
 150         public void createProductNameValidationLessThanMinCharacters() throws Exception {
 151                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 152                 productReqDetails.setName("Pro");
 153                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 154                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
 155                                 createProduct.getErrorCode().intValue());
 156                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
 157                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 158                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1,
 159                                 ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_LENGTH, Constants.EMPTY_STRING, Constants.EMPTY_STRING,
 160                                 null, null, Constants.EMPTY_STRING, "Product", "abbreviated");
 161                 constructFieldsForAuditValidation.setCURR_VERSION("");
 162                 constructFieldsForAuditValidation.setCURR_STATE("");
 163                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 164         }
 165
 166         @Test // (enabled = false)
 167         public void createProductNameValidationMaxLength() throws Exception {
 168                 // Max length = 25
 169                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 170 //              productReqDetails.setName("Qwertyuiop1234567890asdfA");
 171                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
 172                 normalizedName = productReqDetails.getName().toLowerCase();
 173                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 174                 ProductRestUtils.checkCreateResponse(createProduct);
 175                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
 176                 compareExpectedAndActualProducts(productReqDetails, createProduct);
 177                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 178                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 179                                 productManager1.getUserId());
 180                 ProductRestUtils.checkSuccess(getProductRes);
 181                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
 182                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 183                                 ComponentOperationEnum.GET_COMPONENT);
 184                 assertEquals(actualProduct.getIsActive(), new Boolean(false));
 185                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 186                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
 187                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
 188                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 189         }
 190
 191         @Test
 192         public void createProductNameValidationExceedMaxLength() throws Exception {
 193                 // Max length = 25
 194                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 195                 productReqDetails.setName("Qwertyuiop1234567890asdfAa");
 196                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
 197                 normalizedName = productReqDetails.getName().toLowerCase();
 198                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 199                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
 200                                 createProduct.getErrorCode().intValue());
 201                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
 202                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 203                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1,
 204                                 ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_LENGTH, Constants.EMPTY_STRING, Constants.EMPTY_STRING,
 205                                 null, null, Constants.EMPTY_STRING, "Product", "abbreviated");
 206                 constructFieldsForAuditValidation.setCURR_VERSION("");
 207                 constructFieldsForAuditValidation.setCURR_STATE("");
 208                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 209         }
 210
 211         @Test
 212         public void createProductNameValidationEmptyName() throws Exception {
 213                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 214                 productReqDetails.setName("");
 215                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
 216                 normalizedName = productReqDetails.getName().toLowerCase();
 217                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 218                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
 219                                 createProduct.getErrorCode().intValue());
 220                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
 221                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 222                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.MISSING_ONE_OF_COMPONENT_NAMES,
 223                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product",
 224                                 "abbreviated");
 225                 constructFieldsForAuditValidation.setCURR_VERSION("");
 226                 constructFieldsForAuditValidation.setCURR_STATE("");
 227                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 228         }
 229
 230         @Test // (enabled = false)
 231         public void createProductNameAlreadyExist() throws Exception {
 232                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 233                 // productReqDetails.setName("CIProduct1");
 234                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
 235                 normalizedName = productReqDetails.getName().toLowerCase();
 236                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 237                 ProductRestUtils.checkCreateResponse(createProduct);
 238                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
 239                 normalizedName = productReqDetails.getName().toLowerCase();
 240                 // // productReqDetails.setName("CIProduct1");
 241                 DbUtils.deleteFromEsDbByPattern("_all");
 242                 createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 243                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_ALREADY_EXISTS,
 244                                 createProduct.getErrorCode().intValue());
 245                 productReqDetails.setVersion("0.1");
 246                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
 247                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 248                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_NAME_ALREADY_EXIST,
 249                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product",
 250                                 productReqDetails.getName());
 251                 constructFieldsForAuditValidation.setCURR_VERSION("0.1");
 252                 constructFieldsForAuditValidation.setCURR_STATE("");
 253                 constructFieldsForAuditValidation.setCURR_STATE("NOT_CERTIFIED_CHECKOUT");
 254                 constructFieldsForAuditValidation.setSERVICE_INSTANCE_ID(null);
 255                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 256         }
 257
 258         @Test
 259         public void createProductNameValidationNameIsNull() throws Exception {
 260                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 261                 productReqDetails.setName(null);
 262                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 263                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
 264                                 createProduct.getErrorCode().intValue());
 265                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
 266                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 267                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.MISSING_ONE_OF_COMPONENT_NAMES,
 268                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product",
 269                                 "abbreviated");
 270                 constructFieldsForAuditValidation.setCURR_VERSION("");
 271                 constructFieldsForAuditValidation.setCURR_STATE("");
 272                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 273         }
 274
 275         // DE193857
 276         @Test (enabled = false)
 277         public void createProductNameValidationAllowedCharacters() throws Exception {
 278                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 279                 productReqDetails.setName("Ci_2@3:4& m=n+b-u.j-u'g#b"); // Bug @:&=+'#
 280                 normalizedName = "ci234mnbujugb";
 281                 String expectedProductName = "Ci_2@3:4& M=n+b-u.j-u'g#b";
 282                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
 283                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 284                 ProductRestUtils.checkCreateResponse(createProduct);
 285                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
 286                 productReqDetails.setName(expectedProductName);
 287                 productReqDetails.setName("Ci_2@3:4& M=n+b-u.j-u'g#b");
 288                 compareExpectedAndActualProducts(productReqDetails, createProduct);
 289                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 290                 expectedProduct.setNormalizedName(normalizedName);
 291                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 292                                 productManager1.getUserId());
 293                 ProductRestUtils.checkSuccess(getProductRes);
 294                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
 295                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 296                                 ComponentOperationEnum.GET_COMPONENT);
 297                 assertEquals(actualProduct.getIsActive(), new Boolean(false));
 298                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 299                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
 300                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
 301                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 302         }
 303
 304         // DE193857
 305         @Test
 306         public void createProductNameValidationREmoveExtraNonAlphanumericChars() throws Exception {
 307                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 308                 productReqDetails.setName("Ci____222----333......asd");
 309 //              productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
 310                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 311                 ProductRestUtils.checkCreateResponse(createProduct);
 312                 productReqDetails.setName("Ci_222-333.asd");
 313                 normalizedName = "ci222333asd";
 314                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
 315                 compareExpectedAndActualProducts(productReqDetails, createProduct);
 316                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 317                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 318                                 productManager1.getUserId());
 319                 ProductRestUtils.checkSuccess(getProductRes);
 320                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
 321                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 322                                 ComponentOperationEnum.GET_COMPONENT);
 323                 assertEquals(actualProduct.getIsActive(), new Boolean(false));
 324                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 325                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
 326                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
 327                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 328         }
 329
 330         @Test
 331         public void createProductNameValidationNotAllowedCharacters() throws Exception {
 332                 ExpectedProductAudit constructFieldsForAuditValidation;
 333                 char invalidChars[] = { '~', '!', '%', '^', '*', '(', ')', '"', '{', '}', '[', ']', '?', '>', '<', '/', '|',
 334                                 '\\', ',', '$' };
 335                 for (int i = 0; i < invalidChars.length; i++) {
 336                         DbUtils.deleteFromEsDbByPattern("_all");
 337                         ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 338                         productReqDetails.setName("abc" + invalidChars[i]);
 339                         RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 340                         assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
 341                                         createProduct.getErrorCode().intValue());
 342                         Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "",
 343                                         productManager1);
 344                         constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(expectedProduct,
 345                                         CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_FORMAT,
 346                                         Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product",
 347                                         "abbreviated");
 348                         constructFieldsForAuditValidation.setCURR_VERSION("");
 349                         constructFieldsForAuditValidation.setCURR_STATE("");
 350                         AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 351                 }
 352         }
 353
 354         @Test
 355         public void createProductFullNameContainSpecialCharacters() throws Exception {
 356                 char invalidChars[] = { '~', '!', '%', '^', '*', '(', ')', '"', '{', '}', '[', ']', '?', '>', '<', '/', '|',
 357                                 '\\', ',', '$' };
 358                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 359                 for (int i = 0; i < invalidChars.length; i++) {
 360                         DbUtils.deleteFromEsDbByPattern("_all");
 361                         productReqDetails.setFullName("abc" + invalidChars[i]);
 362                         RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 363                         assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_CREATED,
 364                                         createProduct.getErrorCode().intValue());
 365                         RestResponse deleteProduct = ProductRestUtils.deleteProduct(productReqDetails.getUniqueId(),
 366                                         productManager1.getUserId());
 367                         assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS,
 368                                         deleteProduct.getErrorCode().intValue());
 369                 }
 370         }
 371
 372         // Already enabled = false
 373         @Test
 374         public void createProductNameValidationRemoveSpaceFromBeginning() throws Exception {
 375                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 376                 productReqDetails.setName("         Ciertyuiop1234567890asdfA");
 377 //              productReqDetails.setTags(Arrays.asList(productReqDetails.getName().trim()));
 378                 normalizedName = productReqDetails.getName().trim().toLowerCase();
 379                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 380                 ProductRestUtils.checkCreateResponse(createProduct);
 381                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
 382                 productReqDetails.setName("         Ciertyuiop1234567890asdfA".trim());
 383                 compareExpectedAndActualProducts(productReqDetails, createProduct);
 384                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 385                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 386                                 productManager1.getUserId());
 387                 ProductRestUtils.checkSuccess(getProductRes);
 388                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
 389                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 390                                 ComponentOperationEnum.GET_COMPONENT);
 391                 assertEquals(actualProduct.getIsActive(), new Boolean(false));
 392                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 393                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
 394                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
 395                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 396         }
 397
 398         // Already enabled = false
 399         @Test
 400         public void createProductNameValidationRemoveSpaceFromTheEnd() throws Exception {
 401                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 402                 productReqDetails.setName("Ciertyuiop1234567890asdfA        ");
 403 //              productReqDetails.setTags(Arrays.asList(productReqDetails.getName().trim()));
 404                 normalizedName = productReqDetails.getName().trim().toLowerCase();
 405                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 406                 ProductRestUtils.checkCreateResponse(createProduct);
 407                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
 408                 productReqDetails.setName("Ciertyuiop1234567890asdfA        ".trim());
 409                 compareExpectedAndActualProducts(productReqDetails, createProduct);
 410                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 411                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 412                                 productManager1.getUserId());
 413                 ProductRestUtils.checkSuccess(getProductRes);
 414                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
 415                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 416                                 ComponentOperationEnum.GET_COMPONENT);
 417                 assertEquals(actualProduct.getIsActive(), new Boolean(false));
 418                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 419                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
 420                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
 421                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 422         }
 423
 424         @Test
 425         public void createProductNameValidationStartWithNumber() throws Exception {
 426                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 427                 productReqDetails.setName("1Qwert");
 428 //              productReqDetails.setTags(Arrays.asList(productReqDetails.getName().trim()));
 429                 normalizedName = productReqDetails.getName().trim().toLowerCase();
 430                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 431                 ProductRestUtils.checkCreateResponse(createProduct);
 432                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
 433                 compareExpectedAndActualProducts(productReqDetails, createProduct);
 434                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 435                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 436                                 productManager1.getUserId());
 437                 ProductRestUtils.checkSuccess(getProductRes);
 438                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
 439                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 440                                 ComponentOperationEnum.GET_COMPONENT);
 441                 assertEquals(actualProduct.getIsActive(), new Boolean(false));
 442                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 443                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
 444                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
 445                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 446                 productReqDetails.setName("Ci1Qwert");
 447                 RestResponse updateProduct = ProductRestUtils.updateProduct(productReqDetails, productManager1);
 448
 449         }
 450
 451         @Test
 452         public void createProductNameValidationStartWithNonAlphaNumeric() throws Exception {
 453                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 454                 productReqDetails.setName("_Qwert");
 455                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName().trim()));
 456                 normalizedName = productReqDetails.getName().trim().toLowerCase();
 457                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 458                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
 459                                 createProduct.getErrorCode().intValue());
 460                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
 461                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 462                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1,
 463                                 ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_FORMAT, Constants.EMPTY_STRING, Constants.EMPTY_STRING,
 464                                 null, null, Constants.EMPTY_STRING, "Product", "abbreviated");
 465                 constructFieldsForAuditValidation.setCURR_VERSION("");
 466                 constructFieldsForAuditValidation.setCURR_STATE("");
 467                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 468         }
 469
 470         @Test // (enabled = false)
 471         public void createProductNameValidationFirstLetterOfKeyWordsCapitalized() throws Exception {
 472                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 473                 // productReqDetails.setName("Abba");
 474                 // productReqDetails.setTags(Arrays.asList("abba"));
 475                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
 476                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 477                 ProductRestUtils.checkCreateResponse(createProduct);
 478                 // // productReqDetails.setName("Abba");
 479                 /*
 480                  * String actualNormalizedNameFromResponse =
 481                  * ResponseParser.getValueFromJsonResponse(createProduct.getResponse(),
 482                  * "normalizedName");
 483                  * assertTrue(actualNormalizedNameFromResponse.equals(normalizedName));
 484                  */
 485                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
 486                 compareExpectedAndActualProducts(productReqDetails, createProduct);
 487                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 488                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 489                                 productManager1.getUserId());
 490                 ProductRestUtils.checkSuccess(getProductRes);
 491                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
 492                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 493                                 ComponentOperationEnum.GET_COMPONENT);
 494                 assertEquals(actualProduct.getIsActive(), new Boolean(false));
 495                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 496                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
 497                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
 498                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 499         }
 500
 501         @Test
 502         public void createProductFullNameValidationIsEmpty() throws Exception {
 503                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 504                 productReqDetails.setFullName("");
 505                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 506                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
 507                                 createProduct.getErrorCode().intValue());
 508                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
 509                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 510                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.MISSING_ONE_OF_COMPONENT_NAMES,
 511                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product", "full");
 512                 constructFieldsForAuditValidation.setCURR_VERSION("");
 513                 constructFieldsForAuditValidation.setCURR_STATE("");
 514                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 515         }
 516
 517         @Test
 518         public void createProductFullNameValidationIsNull() throws Exception {
 519                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 520                 productReqDetails.setFullName("");
 521                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 522                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
 523                                 createProduct.getErrorCode().intValue());
 524                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
 525                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 526                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.MISSING_ONE_OF_COMPONENT_NAMES,
 527                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product", "full");
 528                 constructFieldsForAuditValidation.setCURR_VERSION("");
 529                 constructFieldsForAuditValidation.setCURR_STATE("");
 530                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 531         }
 532
 533         @Test
 534         public void createProductFullNameLessThanMinLength() throws Exception {
 535                 // Min is 4 characters
 536                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 537                 productReqDetails.setFullName("abc");
 538                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 539                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
 540                                 createProduct.getErrorCode().intValue());
 541                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
 542                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 543                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1,
 544                                 ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_LENGTH, Constants.EMPTY_STRING, Constants.EMPTY_STRING,
 545                                 null, null, Constants.EMPTY_STRING, "Product", "full");
 546                 constructFieldsForAuditValidation.setCURR_VERSION("");
 547                 constructFieldsForAuditValidation.setCURR_STATE("");
 548                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 549         }
 550
 551         @Test // (enabled = false)
 552         public void createProductFullNameHasMinLength() throws Exception {
 553                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 554                 // productReqDetails.setName("Abba");
 555                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
 556                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
 557                 productReqDetails.setFullName("abcd");
 558                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 559                 ProductRestUtils.checkCreateResponse(createProduct);
 560                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
 561                 compareExpectedAndActualProducts(productReqDetails, createProduct);
 562                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 563                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 564                                 productManager1.getUserId());
 565                 ProductRestUtils.checkSuccess(getProductRes);
 566                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
 567                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 568                                 ComponentOperationEnum.GET_COMPONENT);
 569                 assertEquals(actualProduct.getIsActive(), new Boolean(false));
 570                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 571                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
 572                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
 573                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 574         }
 575
 576         @Test // (enabled = false)
 577         public void createProductFullNameHasMaxLength() throws Exception {
 578                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 579                 // productReqDetails.setName("Abba");
 580                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
 581                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
 582                 productReqDetails.setFullName(
 583                                 "Abba1234567890asdfghjk l123zxcvbnm432adfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12");
 584                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 585                 ProductRestUtils.checkCreateResponse(createProduct);
 586                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
 587                 compareExpectedAndActualProducts(productReqDetails, createProduct);
 588                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 589                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 590                                 productManager1.getUserId());
 591                 ProductRestUtils.checkSuccess(getProductRes);
 592                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
 593                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 594                                 ComponentOperationEnum.GET_COMPONENT);
 595                 assertEquals(actualProduct.getIsActive(), new Boolean(false));
 596                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 597                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
 598                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
 599                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 600         }
 601
 602         @Test // (enabled = false)
 603         public void createProductFullNameExceedMaxLength() throws Exception {
 604                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 605                 // productReqDetails.setName("Abba");
 606                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
 607                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
 608                 productReqDetails.setFullName(
 609                                 "Abba1234567890asdfghjk l123zxcvbnm432adfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.123");
 610                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 611                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
 612                                 createProduct.getErrorCode().intValue());
 613                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
 614                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 615                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1,
 616                                 ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_LENGTH, Constants.EMPTY_STRING, Constants.EMPTY_STRING,
 617                                 null, null, Constants.EMPTY_STRING, "Product", "full");
 618                 constructFieldsForAuditValidation.setCURR_VERSION("");
 619                 constructFieldsForAuditValidation.setCURR_STATE("");
 620                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 621         }
 622
 623         @Test // (enabled = false)
 624         public void createProductFullNameRemoveExtraSpaces() throws Exception {
 625                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 626                 // productReqDetails.setName("Abba");
 627                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
 628                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
 629                 productReqDetails.setFullName("Abbaaa  a1");
 630                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 631                 ProductRestUtils.checkCreateResponse(createProduct);
 632                 productReqDetails.setFullName("Abbaaa a1");
 633                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
 634                 compareExpectedAndActualProducts(productReqDetails, createProduct);
 635                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 636                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 637                                 productManager1.getUserId());
 638                 ProductRestUtils.checkSuccess(getProductRes);
 639                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
 640                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 641                                 ComponentOperationEnum.GET_COMPONENT);
 642                 assertEquals(actualProduct.getIsActive(), new Boolean(false));
 643                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 644                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
 645                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
 646                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 647         }
 648
 649         @Test
 650         public void createProductDescriptionValidationIsEmpty() throws Exception {
 651                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 652                 productReqDetails.setDescription("");
 653                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 654                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
 655                                 createProduct.getErrorCode().intValue());
 656                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
 657                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 658                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_MISSING_DESCRIPTION,
 659                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product");
 660                 constructFieldsForAuditValidation.setCURR_VERSION("");
 661                 constructFieldsForAuditValidation.setCURR_STATE("");
 662                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 663         }
 664
 665         @Test
 666         public void createProductDescriptionValidationIsNull() throws Exception {
 667                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 668                 productReqDetails.setDescription(null);
 669                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 670                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
 671                                 createProduct.getErrorCode().intValue());
 672                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
 673                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 674                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_MISSING_DESCRIPTION,
 675                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product");
 676                 constructFieldsForAuditValidation.setCURR_VERSION("");
 677                 constructFieldsForAuditValidation.setCURR_STATE("");
 678                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 679         }
 680
 681         @Test (enabled = false)
 682         public void createProductDescriptionValidCharacters01() throws Exception {
 683                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 684                 // productReqDetails.setName("Abba");
 685                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
 686                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
 687                 productReqDetails.setDescription("qwertyuiopasdfghjklzxcvbnm1234567890<b>Bold<</b>");
 688                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 689                 ProductRestUtils.checkCreateResponse(createProduct);
 690                 productReqDetails.setDescription("qwertyuiopasdfghjklzxcvbnm1234567890Bold&lt;");
 691                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
 692                 compareExpectedAndActualProducts(productReqDetails, createProduct);
 693                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 694                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 695                                 productManager1.getUserId());
 696                 ProductRestUtils.checkSuccess(getProductRes);
 697                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
 698                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 699                                 ComponentOperationEnum.GET_COMPONENT);
 700                 assertEquals(actualProduct.getIsActive(), new Boolean(false));
 701                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 702                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
 703                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
 704                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 705         }
 706
 707         @Test (enabled = false)
 708         public void createProductDescriptionValidCharacters02() throws Exception {
 709                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 710                 // productReqDetails.setName("Abba");
 711                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
 712                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
 713                 productReqDetails.setDescription("~!@#$%^&*()_+<>?qwertyuiopasdfghjklzxcvbnm1234567890#");
 714                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 715                 ProductRestUtils.checkCreateResponse(createProduct);
 716                 productReqDetails.setDescription("~!@#$%^&amp;*()_+&lt;&gt;?qwertyuiopasdfghjklzxcvbnm1234567890#");
 717                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
 718                 compareExpectedAndActualProducts(productReqDetails, createProduct);
 719                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 720                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 721                                 productManager1.getUserId());
 722                 ProductRestUtils.checkSuccess(getProductRes);
 723                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
 724                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 725                                 ComponentOperationEnum.GET_COMPONENT);
 726                 assertEquals(actualProduct.getIsActive(), new Boolean(false));
 727                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 728                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
 729                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
 730                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 731         }
 732
 733         @Test // (enabled = false)
 734         public void createProductDescriptionInValidCharacters() throws Exception {
 735                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 736                 // productReqDetails.setName("Abba");
 737                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
 738                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
 739                 productReqDetails.setDescription("מה");
 740                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 741                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
 742                                 createProduct.getErrorCode().intValue());
 743                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
 744                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 745                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_INVALID_DESCRIPTION,
 746                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product");
 747                 constructFieldsForAuditValidation.setCURR_VERSION("");
 748                 constructFieldsForAuditValidation.setCURR_STATE("");
 749                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 750         }
 751
 752         @Test (enabled = false)
 753         public void createProductDescriptionRemoveSpacesFromBeginning() throws Exception {
 754                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 755                 // productReqDetails.setName("Abba");
 756                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
 757                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
 758                 productReqDetails.setDescription("   abcd12345");
 759                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 760                 ProductRestUtils.checkCreateResponse(createProduct);
 761                 productReqDetails.setDescription("abcd12345");
 762                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
 763                 compareExpectedAndActualProducts(productReqDetails, createProduct);
 764                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 765                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 766                                 productManager1.getUserId());
 767                 ProductRestUtils.checkSuccess(getProductRes);
 768                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
 769                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 770                                 ComponentOperationEnum.GET_COMPONENT);
 771                 assertEquals(actualProduct.getIsActive(), new Boolean(false));
 772                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 773                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
 774                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
 775                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 776         }
 777
 778         @Test (enabled = false)
 779         public void createProductDescriptionRemoveSpacesFromTheEnd() throws Exception {
 780                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 781                 // productReqDetails.setName("Abba");
 782                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
 783                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
 784                 productReqDetails.setDescription("abcd 12345 xcvb    ");
 785                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 786                 ProductRestUtils.checkCreateResponse(createProduct);
 787                 productReqDetails.setDescription("abcd 12345 xcvb");
 788                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
 789                 compareExpectedAndActualProducts(productReqDetails, createProduct);
 790                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 791                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 792                                 productManager1.getUserId());
 793                 ProductRestUtils.checkSuccess(getProductRes);
 794                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
 795                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 796                                 ComponentOperationEnum.GET_COMPONENT);
 797                 assertEquals(actualProduct.getIsActive(), new Boolean(false));
 798                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 799                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
 800                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
 801                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 802         }
 803
 804         @Test // (enabled = false)
 805         public void createProductDescriptionMaxLength() throws Exception {
 806                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 807                 // productReqDetails.setName("Abba");
 808                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
 809                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
 810                 productReqDetails.setDescription(
 811                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12asdfghjklzxcvbnmqwertyui");
 812                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 813                 ProductRestUtils.checkCreateResponse(createProduct);
 814                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
 815                 compareExpectedAndActualProducts(productReqDetails, createProduct);
 816                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 817                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 818                                 productManager1.getUserId());
 819                 ProductRestUtils.checkSuccess(getProductRes);
 820                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
 821                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 822                                 ComponentOperationEnum.GET_COMPONENT);
 823                 assertEquals(actualProduct.getIsActive(), new Boolean(false));
 824                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 825                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
 826                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
 827                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 828         }
 829
 830         @Test // (enabled = false)
 831         public void createProductDescriptionExceedMaxLength() throws Exception {
 832                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 833                 // productReqDetails.setName("Abba");
 834                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
 835                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
 836                 productReqDetails.setDescription(
 837                                 "Abxba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12Abba1234567890asdfghjkl123zxcvbnm432asdfghjkl_-.123Abba1234567890asdfghjkl23zxcvbnm432asdfghjkl_-.12asdfghjklzxcvbnmqwertyui");
 838                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 839                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
 840                                 createProduct.getErrorCode().intValue());
 841                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
 842                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 843                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_DESCRIPTION_EXCEEDS_LIMIT,
 844                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product", "1024");
 845                 constructFieldsForAuditValidation.setCURR_VERSION("");
 846                 constructFieldsForAuditValidation.setCURR_STATE("");
 847                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 848         }
 849
 850         @Test
 851         public void createProductTagIsEmpty() throws Exception {
 852                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 853                 productReqDetails.setName("Product");
 854                 productReqDetails.setTags(Arrays.asList(""));
 855                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
 856                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 857                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
 858                                 createProduct.getErrorCode().intValue());
 859                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
 860                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 861                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.INVALID_FIELD_FORMAT,
 862                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product", "tag");
 863                 constructFieldsForAuditValidation.setCURR_VERSION("");
 864                 constructFieldsForAuditValidation.setCURR_STATE("");
 865                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 866         }
 867
 868         // DE192351
 869         @Test // (enabled = false)
 870         public void createProductTagValidationAllowedCharacters() throws Exception {
 871                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 872                 // productReqDetails.setName("CIProduct1"); // Bug @:&=+'#
 873                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName(), "Acde2@3:4& m=n+b-u.j-u'g#b"));
 874                 normalizedName = productReqDetails.getName().toLowerCase();
 875                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 876                 ProductRestUtils.checkCreateResponse(createProduct);
 877                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
 878                 compareExpectedAndActualProducts(productReqDetails, createProduct);
 879                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 880                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 881                                 productManager1.getUserId());
 882                 ProductRestUtils.checkSuccess(getProductRes);
 883                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
 884                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 885                                 ComponentOperationEnum.GET_COMPONENT);
 886                 assertEquals(actualProduct.getIsActive(), new Boolean(false));
 887                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 888                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
 889                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
 890                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 891         }
 892
 893         @Test // (enabled = false)
 894         public void createProductTagsNameValidationProductNameIsNotInTag() throws Exception {
 895                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 896 //              productReqDetails.setName("Qwertyuiop1234567890asdfA");
 897                 productReqDetails.setTags(Arrays.asList("Abc"));
 898                 normalizedName = productReqDetails.getName().trim().toLowerCase();
 899                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 900                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
 901                                 createProduct.getErrorCode().intValue());
 902                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
 903                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 904                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_INVALID_TAGS_NO_COMP_NAME,
 905                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
 906                 constructFieldsForAuditValidation.setCURR_VERSION("");
 907                 constructFieldsForAuditValidation.setCURR_STATE("");
 908                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 909         }
 910
 911         @Test // (enabled = false)
 912         public void createProductSingleTagMaxLength() throws Exception {
 913                 // SingleTagMaxLength = 50
 914                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 915                 // productReqDetails.setName("CIProduct1");
 916                 productReqDetails.setTags(
 917                                 Arrays.asList(productReqDetails.getName(), "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345678"));
 918                 normalizedName = productReqDetails.getName().toLowerCase();
 919                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 920                 ProductRestUtils.checkCreateResponse(createProduct);
 921                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
 922                 compareExpectedAndActualProducts(productReqDetails, createProduct);
 923                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 924                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 925                                 productManager1.getUserId());
 926                 ProductRestUtils.checkSuccess(getProductRes);
 927                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
 928                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 929                                 ComponentOperationEnum.GET_COMPONENT);
 930                 assertEquals(actualProduct.getIsActive(), new Boolean(false));
 931                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 932                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
 933                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
 934                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 935         }
 936
 937         @Test (enabled = false)
 938         public void createProductSingleTagExceedMaxLength() throws Exception {
 939                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 940                 // productReqDetails.setName("CIProduct1"); // Bug @:&=+'#
 941                 productReqDetails.setTags(
 942                                 Arrays.asList(productReqDetails.getName(), "Axbba1234567890asdfghjkl123zxcvbnm432asdfgh12345678"));
 943                 normalizedName = productReqDetails.getName().toLowerCase();
 944                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 945                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
 946                                 createProduct.getErrorCode().intValue());
 947                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
 948                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 949                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_SINGLE_TAG_EXCEED_LIMIT,
 950                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "50");
 951                 constructFieldsForAuditValidation.setCURR_VERSION("");
 952                 constructFieldsForAuditValidation.setCURR_STATE("");
 953                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 954         }
 955
 956         @Test (enabled = false)
 957         public void createProductAllTagsMaxLength() throws Exception {
 958                 // AllTagsMaxLength = 1024
 959                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
 960                 // productReqDetails.setName("CIProduct1");
 961                 productReqDetails.setTags(
 962                                 Arrays.asList(productReqDetails.getName(), "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345601",
 963                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345602",
 964                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345603",
 965                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345604",
 966                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345605",
 967                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345606",
 968                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345607",
 969                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345608",
 970                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh1234569",
 971                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345610",
 972                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345611",
 973                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345612",
 974                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345613",
 975                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345614",
 976                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345615",
 977                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345616",
 978                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345617",
 979                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345618",
 980                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345619",
 981                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345"));
 982                 normalizedName = productReqDetails.getName().toLowerCase();
 983                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
 984                 ProductRestUtils.checkCreateResponse(createProduct);
 985                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
 986                 compareExpectedAndActualProducts(productReqDetails, createProduct);
 987                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
 988                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
 989                                 productManager1.getUserId());
 990                 ProductRestUtils.checkSuccess(getProductRes);
 991                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
 992                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
 993                                 ComponentOperationEnum.GET_COMPONENT);
 994                 assertEquals(actualProduct.getIsActive(), new Boolean(false));
 995                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
 996                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
 997                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
 998                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
 999         }
1000
1001         @Test
1002         public void createProductAllTagsExceedMaxLength() throws Exception {
1003                 // AllTagsMaxLength = 1024
1004                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1005                 // productReqDetails.setName("CIProduct1");
1006                 productReqDetails.setTags(
1007                                 Arrays.asList(productReqDetails.getName(), "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345601",
1008                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345602",
1009                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345603",
1010                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345604",
1011                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345605",
1012                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345606",
1013                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345607",
1014                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345608",
1015                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh1234569",
1016                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345610",
1017                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345611",
1018                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345612",
1019                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345613",
1020                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345614",
1021                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345615",
1022                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345616",
1023                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345617",
1024                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345618",
1025                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh12345619",
1026                                                 "Abba1234567890asdfghjkl123zxcvbnm432asdfgh123456"));
1027                 normalizedName = productReqDetails.getName().toLowerCase();
1028                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1029                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1030                                 createProduct.getErrorCode().intValue());
1031                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1032                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1033                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_TAGS_EXCEED_LIMIT,
1034                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "1024");
1035                 constructFieldsForAuditValidation.setCURR_VERSION("");
1036                 constructFieldsForAuditValidation.setCURR_STATE("");
1037                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1038         }
1039
1040         @Test // (enabled = false)
1041         public void createProductDuplicateTagRemoved() throws Exception {
1042                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1043                 // productReqDetails.setName("CIProduct1"); // Bug @:&=+'#
1044                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName(), productReqDetails.getName()));
1045                 normalizedName = productReqDetails.getName().toLowerCase();
1046                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1047                 ProductRestUtils.checkCreateResponse(createProduct);
1048                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1049                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
1050                 compareExpectedAndActualProducts(productReqDetails, createProduct);
1051                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1052                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1053                                 productManager1.getUserId());
1054                 ProductRestUtils.checkSuccess(getProductRes);
1055                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1056                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1057                                 ComponentOperationEnum.GET_COMPONENT);
1058                 assertEquals(actualProduct.getIsActive(), new Boolean(false));
1059                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1060                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
1061                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
1062                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1063         }
1064
1065         @Test // (enabled = false)
1066         public void createProductContactsIsEmpty() throws Exception {
1067                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1068                 // productReqDetails.setName("CIProduct1"); // Bug @:&=+'#
1069                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1070                 normalizedName = productReqDetails.getName().toLowerCase();
1071                 productReqDetails.setContacts(Arrays.asList(""));
1072                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1073                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1074                                 createProduct.getErrorCode().intValue());
1075                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1076                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1077                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_INVALID_CONTACT,
1078                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product");
1079                 constructFieldsForAuditValidation.setCURR_VERSION("");
1080                 constructFieldsForAuditValidation.setCURR_STATE("");
1081                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1082         }
1083
1084         @Test // (enabled = false)
1085         public void createProductContactsInvalidFormat() throws Exception {
1086                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1087                 // productReqDetails.setName("CIProduct1"); // Bug @:&=+'#
1088                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1089                 normalizedName = productReqDetails.getName().toLowerCase();
1090                 productReqDetails.setContacts(Arrays.asList("bt750345"));
1091                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1092                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1093                                 createProduct.getErrorCode().intValue());
1094                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1095                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1096                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_INVALID_CONTACT,
1097                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product");
1098                 constructFieldsForAuditValidation.setCURR_VERSION("");
1099                 constructFieldsForAuditValidation.setCURR_STATE("");
1100                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1101         }
1102
1103         @Test // (enabled = false)
1104         public void createProductConvertContactsToLowerCase() throws Exception {
1105                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1106                 // productReqDetails.setName("CIProduct1"); // Bug @:&=+'#
1107                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1108                 normalizedName = productReqDetails.getName().toLowerCase();
1109                 productReqDetails.setContacts(Arrays.asList(productManager1.getUserId().toUpperCase()));
1110                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1111                 ProductRestUtils.checkCreateResponse(createProduct);
1112                 productReqDetails.setContacts(Arrays.asList(productManager1.getUserId().toLowerCase()));
1113                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
1114                 compareExpectedAndActualProducts(productReqDetails, createProduct);
1115                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1116                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1117                                 productManager1.getUserId());
1118                 ProductRestUtils.checkSuccess(getProductRes);
1119                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1120                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1121                                 ComponentOperationEnum.GET_COMPONENT);
1122                 assertEquals(actualProduct.getIsActive(), new Boolean(false));
1123                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1124                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
1125                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
1126                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1127         }
1128
1129         @Test // (enabled = false)
1130         public void createProductContactsDoexNotContainTheProductCreator() throws Exception {
1131                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1132                 // productReqDetails.setName("CIProduct1"); // Bug @:&=+'#
1133                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1134                 normalizedName = productReqDetails.getName().toLowerCase();
1135                 productReqDetails.setContacts(Arrays.asList(productManager2.getUserId()));
1136                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1137                 ProductRestUtils.checkCreateResponse(createProduct);
1138                 productReqDetails.setContacts(Arrays.asList(productManager2.getUserId(), productManager1.getUserId()));
1139                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
1140                 compareExpectedAndActualProducts(productReqDetails, createProduct);
1141                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1142                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1143                                 productManager1.getUserId());
1144                 ProductRestUtils.checkSuccess(getProductRes);
1145                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1146                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1147                                 ComponentOperationEnum.GET_COMPONENT);
1148                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1149                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
1150                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
1151                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1152         }
1153
1154         @Test // (enabled = false)
1155         public void createProductContactsNotAllowedAsdcUsers() throws Exception {
1156                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1157                 // productReqDetails.setName("CIProduct1"); // Bug @:&=+'#
1158                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1159                 normalizedName = productReqDetails.getName().toLowerCase();
1160                 productReqDetails.setContacts(Arrays.asList(designerUser.getUserId()));
1161                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1162                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1163                                 createProduct.getErrorCode().intValue());
1164                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1165                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1166                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.INVALID_PRODUCT_CONTACT,
1167                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING,
1168                                 designerUser.getUserId());
1169                 constructFieldsForAuditValidation.setCURR_VERSION("");
1170                 constructFieldsForAuditValidation.setCURR_STATE("");
1171                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1172         }
1173
1174         @Test // (enabled = false)
1175         public void createProductContactsNotAsdcUser() throws Exception {
1176                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1177                 // productReqDetails.setName("CIProduct1"); // Bug @:&=+'#
1178                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1179                 normalizedName = productReqDetails.getName().toLowerCase();
1180                 String nonAsdcUser = "bh1234";
1181                 productReqDetails.setContacts(Arrays.asList(nonAsdcUser));
1182                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1183                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1184                                 createProduct.getErrorCode().intValue());
1185                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1186                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1187                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.INVALID_PRODUCT_CONTACT,
1188                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, nonAsdcUser);
1189                 constructFieldsForAuditValidation.setCURR_VERSION("");
1190                 constructFieldsForAuditValidation.setCURR_STATE("");
1191                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1192         }
1193
1194         @Test // (enabled = false)
1195         public void createProductProjectCodeIsEmpty() throws Exception {
1196                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1197                 // productReqDetails.setName("CIProduct1");
1198                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1199                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1200                 productReqDetails.setProjectCode("");
1201                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1202                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1203                                 createProduct.getErrorCode().intValue());
1204                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1205                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1206                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.MISSING_PROJECT_CODE,
1207                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
1208                 constructFieldsForAuditValidation.setCURR_VERSION("");
1209                 constructFieldsForAuditValidation.setCURR_STATE("");
1210                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1211         }
1212
1213         @Test // (enabled = false)
1214         public void createProductProjectCodeIsNull() throws Exception {
1215                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1216                 // productReqDetails.setName("CIProduct1");
1217                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1218                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1219                 productReqDetails.setProjectCode(null);
1220                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1221                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1222                                 createProduct.getErrorCode().intValue());
1223                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1224                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1225                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.MISSING_PROJECT_CODE,
1226                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
1227                 constructFieldsForAuditValidation.setCURR_VERSION("");
1228                 constructFieldsForAuditValidation.setCURR_STATE("");
1229                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1230         }
1231
1232         @Test // (enabled = false)
1233         public void createProductProjectCodeIsNotNumeric() throws Exception {
1234                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1235                 // productReqDetails.setName("CIProduct1");
1236                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1237                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1238                 productReqDetails.setProjectCode("asdfgh");
1239                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1240                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1241                                 createProduct.getErrorCode().intValue());
1242                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1243                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1244                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.INVALID_PROJECT_CODE,
1245                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
1246                 constructFieldsForAuditValidation.setCURR_VERSION("");
1247                 constructFieldsForAuditValidation.setCURR_STATE("");
1248                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1249         }
1250
1251         @Test // (enabled = false)
1252         public void createProductProjectCodeHasnMinCharacters() throws Exception {
1253                 // Min =5
1254                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1255                 // productReqDetails.setName("CIProduct1");
1256                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1257                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1258                 productReqDetails.setProjectCode("12345");
1259                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1260                 ProductRestUtils.checkCreateResponse(createProduct);
1261                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
1262                 compareExpectedAndActualProducts(productReqDetails, createProduct);
1263                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1264                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1265                                 productManager1.getUserId());
1266                 ProductRestUtils.checkSuccess(getProductRes);
1267                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1268                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1269                                 ComponentOperationEnum.GET_COMPONENT);
1270                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1271                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
1272                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
1273                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1274         }
1275
1276         @Test // (enabled = false)
1277         public void createProductProjectCodeHasnMaxCharacters() throws Exception {
1278                 // Max =10
1279                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1280                 // productReqDetails.setName("CIProduct1");
1281                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1282                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1283                 productReqDetails.setProjectCode("1234567890");
1284                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1285                 ProductRestUtils.checkCreateResponse(createProduct);
1286                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
1287                 compareExpectedAndActualProducts(productReqDetails, createProduct);
1288                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1289                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1290                                 productManager1.getUserId());
1291                 ProductRestUtils.checkSuccess(getProductRes);
1292                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1293                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1294                                 ComponentOperationEnum.GET_COMPONENT);
1295                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1296                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
1297                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
1298                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1299         }
1300
1301         @Test // (enabled = false)
1302         public void createProductProjectCodeExceedMaxCharacters() throws Exception {
1303                 // Max =10
1304                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1305                 // productReqDetails.setName("CIProduct1");
1306                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1307                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1308                 productReqDetails.setProjectCode("12345678901");
1309                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1310                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1311                                 createProduct.getErrorCode().intValue());
1312                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1313                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1314                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.INVALID_PROJECT_CODE,
1315                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
1316                 constructFieldsForAuditValidation.setCURR_VERSION("");
1317                 constructFieldsForAuditValidation.setCURR_STATE("");
1318                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1319         }
1320
1321         @Test // (enabled = false)
1322         public void createProductProjectCodeLessThanMinCharacters() throws Exception {
1323                 // Max =10
1324                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1325                 // productReqDetails.setName("CIProduct1");
1326                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1327                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1328                 productReqDetails.setProjectCode("1234");
1329                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1330                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1331                                 createProduct.getErrorCode().intValue());
1332                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1333                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1334                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.INVALID_PROJECT_CODE,
1335                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
1336                 constructFieldsForAuditValidation.setCURR_VERSION("");
1337                 constructFieldsForAuditValidation.setCURR_STATE("");
1338                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1339         }
1340
1341         @Test // (enabled = false)
1342         public void createProductIconIsEmpty() throws Exception {
1343                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1344                 // productReqDetails.setName("CIProduct1");
1345                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1346                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1347                 productReqDetails.setIcon("");
1348                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1349                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1350                                 createProduct.getErrorCode().intValue());
1351                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1352                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1353                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_MISSING_ICON,
1354                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product");
1355                 constructFieldsForAuditValidation.setCURR_VERSION("");
1356                 constructFieldsForAuditValidation.setCURR_STATE("");
1357                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1358         }
1359
1360         @Test // (enabled = false)
1361         public void createProductIconIsNull() throws Exception {
1362                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1363                 // productReqDetails.setName("CIProduct1");
1364                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1365                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1366                 productReqDetails.setIcon(null);
1367                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1368                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1369                                 createProduct.getErrorCode().intValue());
1370                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1371                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1372                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_MISSING_ICON,
1373                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product");
1374                 constructFieldsForAuditValidation.setCURR_VERSION("");
1375                 constructFieldsForAuditValidation.setCURR_STATE("");
1376                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1377         }
1378
1379         @Test // (enabled = false)
1380         public void createProductIconMaxLength() throws Exception {
1381                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1382                 // productReqDetails.setName("CIProduct1");
1383                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1384                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1385                 productReqDetails.setIcon("asdfghjklqwertyuiozxcvbfv");
1386                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1387                 ProductRestUtils.checkCreateResponse(createProduct);
1388                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
1389                 compareExpectedAndActualProducts(productReqDetails, createProduct);
1390                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1391                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1392                                 productManager1.getUserId());
1393                 ProductRestUtils.checkSuccess(getProductRes);
1394                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1395                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1396                                 ComponentOperationEnum.GET_COMPONENT);
1397                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1398                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
1399                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
1400                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1401         }
1402
1403         @Test // (enabled = false)
1404         public void createProductIconExceedMaxLength() throws Exception {
1405                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1406                 // productReqDetails.setName("CIProduct1");
1407                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1408                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1409                 productReqDetails.setIcon("asdfghjklqwertyuiozxcvbf12");
1410                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1411                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1412                                 createProduct.getErrorCode().intValue());
1413                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1414                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1415                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_ICON_EXCEEDS_LIMIT,
1416                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product", "25");
1417                 constructFieldsForAuditValidation.setCURR_VERSION("");
1418                 constructFieldsForAuditValidation.setCURR_STATE("");
1419                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1420         }
1421
1422         @Test // (enabled = false)
1423         public void createProductIconAllowedCharacters() throws Exception {
1424                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1425                 // productReqDetails.setName("CIProduct1");
1426                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1427                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1428                 productReqDetails.setIcon("a--s-fghjk_q__r1234567890");
1429                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1430                 ProductRestUtils.checkCreateResponse(createProduct);
1431                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
1432                 compareExpectedAndActualProducts(productReqDetails, createProduct);
1433                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1434                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1435                                 productManager1.getUserId());
1436                 ProductRestUtils.checkSuccess(getProductRes);
1437                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1438                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1439                                 ComponentOperationEnum.GET_COMPONENT);
1440                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1441                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
1442                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
1443                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1444         }
1445
1446         @Test (enabled = false)
1447         public void createProductIconInValidCharacters() throws Exception {
1448                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1449                 // productReqDetails.setName("CIProduct1");
1450                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1451                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1452                 String icon = "asdfg";
1453                 char invalidChars[] = { '~', '!', '$', '%', '^', '*', '(', ')', '"', '{', '}', '[', ']', '?', '>', '<', '/',
1454                                 '|', '\\', ',' };
1455                 RestResponse createProduct;
1456                 for (int i = 0; i < invalidChars.length; i++) {
1457                         productReqDetails.setIcon(icon + invalidChars[i]);
1458                         createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1459                         assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1460                                         createProduct.getErrorCode().intValue());
1461                         Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "",
1462                                         productManager1);
1463                         ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1464                                         expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.COMPONENT_INVALID_ICON,
1465                                         Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING, "Product");
1466                         constructFieldsForAuditValidation.setCURR_VERSION("");
1467                         constructFieldsForAuditValidation.setCURR_STATE("");
1468                         AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1469                 }
1470         }
1471
1472         @Test // (enabled = false)
1473         public void createProductIsActiveisEmpty() throws Exception {
1474                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1475                 // productReqDetails.setName("CIProduct1");
1476                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1477                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1478                 productReqDetails.setActive("");
1479                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1480                 ProductRestUtils.checkCreateResponse(createProduct);
1481                 productReqDetails.setActive("false");
1482                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
1483                 compareExpectedAndActualProducts(productReqDetails, createProduct);
1484                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1485                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1486                                 productManager1.getUserId());
1487                 ProductRestUtils.checkSuccess(getProductRes);
1488                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1489                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1490                                 ComponentOperationEnum.GET_COMPONENT);
1491                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1492                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
1493                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
1494                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1495         }
1496
1497         @Test // (enabled = false)
1498         public void createProductIsActiveisNull() throws Exception {
1499                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1500                 // productReqDetails.setName("CIProduct1");
1501                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1502                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1503                 productReqDetails.setActive("");
1504                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1505                 ProductRestUtils.checkCreateResponse(createProduct);
1506                 productReqDetails.setActive("false");
1507                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
1508                 compareExpectedAndActualProducts(productReqDetails, createProduct);
1509                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1510                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1511                                 productManager1.getUserId());
1512                 ProductRestUtils.checkSuccess(getProductRes);
1513                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1514                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1515                                 ComponentOperationEnum.GET_COMPONENT);
1516                 assertEquals(actualProduct.getIsActive(), new Boolean(false));
1517                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1518                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
1519                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
1520                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1521         }
1522
1523         @Test // (enabled = false)
1524         public void createProductIsActiveisFalse() throws Exception {
1525                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1526                 // productReqDetails.setName("CIProduct1");
1527                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1528                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1529                 productReqDetails.setActive("false");
1530                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1531                 ProductRestUtils.checkCreateResponse(createProduct);
1532                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
1533                 compareExpectedAndActualProducts(productReqDetails, createProduct);
1534                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1535                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1536                                 productManager1.getUserId());
1537                 ProductRestUtils.checkSuccess(getProductRes);
1538                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1539                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1540                                 ComponentOperationEnum.GET_COMPONENT);
1541                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1542                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
1543                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
1544                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1545         }
1546
1547         @Test
1548         public void createProductIsActiveisHasInvalidValue() throws Exception {
1549                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1550                 // productReqDetails.setName("CIProduct1");
1551                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1552                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1553                 productReqDetails.setActive("xfalse");
1554                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1555                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_INVALID_CONTENT,
1556                                 createProduct.getErrorCode().intValue());
1557                 Product expectedProduct = Convertor.constructFieldsForRespValidation(productReqDetails, "", productManager1);
1558                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1559                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.INVALID_CONTENT,
1560                                 Constants.EMPTY_STRING, Constants.EMPTY_STRING, null, null, Constants.EMPTY_STRING);
1561                 constructFieldsForAuditValidation.setCURR_VERSION("");
1562                 constructFieldsForAuditValidation.setCURR_STATE("");
1563                 constructFieldsForAuditValidation.setRESOURCE_NAME("");
1564                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1565         }
1566
1567         @Test // (enabled = false)
1568         public void createProductIsActiveisTrue() throws Exception {
1569                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1570                 // productReqDetails.setName("CIProduct1");
1571                 productReqDetails.setTags(Arrays.asList(productReqDetails.getName()));
1572                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1573                 productReqDetails.setActive("true");
1574                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1575                 ProductRestUtils.checkCreateResponse(createProduct);
1576                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
1577                 compareExpectedAndActualProducts(productReqDetails, createProduct);
1578                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1579                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1580                                 productManager1.getUserId());
1581                 ProductRestUtils.checkSuccess(getProductRes);
1582                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1583                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1584                                 ComponentOperationEnum.GET_COMPONENT);
1585                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1586                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
1587                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
1588                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1589         }
1590
1591         //////////////////////////////////////////////
1592         // DE192424
1593         @Test // (enabled = false)
1594         public void createProductNameValidationNormalizationNameWithSpaces() throws Exception {
1595                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1596 //              productReqDetails.setName("Abba Emma");
1597                 // productReqDetails.setName("abba emma");
1598                 // productReqDetails.setTags(Arrays.asList("abba emma"));
1599                 normalizedName = productReqDetails.getName().toLowerCase().replaceAll("\\s+", "");
1600                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1601                 ProductRestUtils.checkCreateResponse(createProduct);
1602                 String actualNormalizedNameFromResponse = ResponseParser.getValueFromJsonResponse(createProduct.getResponse(),
1603                                 "normalizedName");
1604                 assertTrue(actualNormalizedNameFromResponse.equals(normalizedName));
1605                 // productReqDetails.setName("Abba Emma");
1606                 String productUuid = ResponseParser.getUuidFromResponse(createProduct);
1607                 compareExpectedAndActualProducts(productReqDetails, createProduct);
1608                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1609                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1610                                 productManager1.getUserId());
1611                 ProductRestUtils.checkSuccess(getProductRes);
1612                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1613                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1614                                 ComponentOperationEnum.GET_COMPONENT);
1615                 assertEquals(actualProduct.getIsActive(), new Boolean(false));
1616                 ExpectedProductAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(
1617                                 expectedProduct, CREATE_AUDIT_ACTION, productManager1, ActionStatus.CREATED, Constants.EMPTY_STRING,
1618                                 "0.1", null, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, productUuid);
1619                 AuditValidationUtils.validateAuditProduct(constructFieldsForAuditValidation, CREATE_AUDIT_ACTION);
1620         }
1621
1622         private void compareExpectedAndActualProducts(ProductReqDetails productReqDetails, RestResponse createProduct)
1623                         throws JSONException {
1624                 String productName = ResponseParser.getNameFromResponse(createProduct);
1625                 assertTrue(productReqDetails.getName().equals(productName));
1626                 String productIcon = ResponseParser.getValueFromJsonResponse(createProduct.getResponse(), "icon");
1627                 assertTrue(productReqDetails.getIcon().equals(productIcon));
1628                 String productFullName = ResponseParser.getValueFromJsonResponse(createProduct.getResponse(), "fullName");
1629                 assertTrue(productReqDetails.getFullName().equals(productFullName));
1630                 String productProjectCode = ResponseParser.getValueFromJsonResponse(createProduct.getResponse(), "projectCode");
1631                 assertTrue(productReqDetails.getProjectCode().equals(productProjectCode));
1632                 String productIsActive = ResponseParser.getValueFromJsonResponse(createProduct.getResponse(), "isActive");
1633                 String expectedIsActive = (productReqDetails.getActive() != null ? productReqDetails.getActive() : "false");
1634                 assertTrue(productIsActive.equals(expectedIsActive));
1635                 String productdescription = ResponseParser.getValueFromJsonResponse(createProduct.getResponse(), "description");
1636                 assertTrue(productReqDetails.getDescription().equals(productdescription));
1637                 String productNormalizedName = ResponseParser.getValueFromJsonResponse(createProduct.getResponse(),
1638                                 "normalizedName");
1639                 assertTrue(normalizedName.equals(productNormalizedName));
1640                 String productContacts = ResponseParser.getValueFromJsonResponse(createProduct.getResponse(), "contacts");
1641                 JSONArray reciviedContacts = new JSONArray(productContacts);
1642                 String actualContact = null;
1643                 for (int i = 0; i < reciviedContacts.length(); i++) {
1644                         actualContact = reciviedContacts.getString(i);
1645                         assertEquals(productReqDetails.getContacts().get(i), actualContact);
1646                 }
1647                 String productTags = ResponseParser.getValueFromJsonResponse(createProduct.getResponse(), "tags");
1648                 JSONArray reciviedTages = new JSONArray(productTags);
1649                 String actualTag = null;
1650                 for (int i = 0; i < reciviedTages.length(); i++) {
1651                         actualTag = reciviedTages.getString(i);
1652                         assertEquals(productReqDetails.getTags().get(i), actualTag);
1653                 }
1654         }
1655
1656         // END
1657         ///////////////////////////////////////////////////////
1658         @Test
1659         public void createProductSuccessFlow() throws Exception {
1660                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1661                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1662                 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_CREATED,
1663                                 createProduct.getErrorCode().intValue());
1664
1665                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1666                                 productManager1.getUserId());
1667                 assertEquals("Check response code after getting created Product", BaseRestUtils.STATUS_CODE_SUCCESS,
1668                                 getProductRes.getErrorCode().intValue());
1669
1670                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1671                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1672                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1673                                 ComponentOperationEnum.GET_COMPONENT);
1674                 assertEquals(actualProduct.getIsActive(), new Boolean(false));
1675         }
1676
1677         @Test
1678         public void createProductSetIsActive() throws Exception {
1679                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1680                 productReqDetails.setActive("true");
1681                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1682                 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_CREATED,
1683                                 createProduct.getErrorCode().intValue());
1684
1685                 RestResponse getProductRes = ProductRestUtils.getProduct(productReqDetails.getUniqueId(),
1686                                 productManager1.getUserId());
1687                 assertEquals("Check response code after getting created Product", BaseRestUtils.STATUS_CODE_SUCCESS,
1688                                 getProductRes.getErrorCode().intValue());
1689
1690                 Product expectedProduct = ResponseParser.parseToObjectUsingMapper(createProduct.getResponse(), Product.class);
1691                 Product actualProduct = ResponseParser.parseToObjectUsingMapper(getProductRes.getResponse(), Product.class);
1692                 ProductValidationUtils.compareExpectedAndActualProducts(expectedProduct, actualProduct,
1693                                 ComponentOperationEnum.GET_COMPONENT);
1694                 assertEquals(actualProduct.getIsActive(), new Boolean(true));
1695         }
1696
1697         @Test
1698         public void createProductNoIcon() throws Exception {
1699                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1700                 productReqDetails.setIcon(null);
1701                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1702                 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_MISSING_DATA,
1703                                 createProduct.getErrorCode().intValue());
1704
1705         }
1706
1707         @Test
1708         public void createProductNoProjectCode() throws Exception {
1709                 ProductReqDetails productReqDetails = ElementFactory.getDefaultProduct();
1710                 productReqDetails.setProjectCode(null);
1711                 RestResponse createProduct = ProductRestUtils.createProduct(productReqDetails, productManager1);
1712                 assertEquals("Check response code after create Product", BaseRestUtils.STATUS_CODE_MISSING_DATA,
1713                                 createProduct.getErrorCode().intValue());
1714
1715         }
1716
1717 }