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