gerrit.onap Code Review - sdc.git/blob

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