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