test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/category/GroupingTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.ci.tests.execute.category;
  22
  23 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.PRODUCT_COMPONENT_TYPE;
  24 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.RESOURCE_COMPONENT_TYPE;
  25 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.SERVICE_COMPONENT_TYPE;
  26 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_ALREADY_EXISTS;
  27 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_CREATED;
  28 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_INVALID_CONTENT;
  29 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_MISSING_INFORMATION;
  30 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_NOT_FOUND;
  31 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_RESTRICTED_OPERATION;
  32 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_SUCCESS;
  33 import static org.testng.AssertJUnit.assertEquals;
  34
  35 import java.util.ArrayList;
  36 import java.util.List;
  37
  38 import org.junit.Rule;
  39 import org.junit.rules.TestName;
  40 import org.openecomp.sdc.be.dao.api.ActionStatus;
  41 import org.openecomp.sdc.be.model.User;
  42 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  43 import org.openecomp.sdc.be.model.category.GroupingDefinition;
  44 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
  45 import org.openecomp.sdc.ci.tests.datatypes.enums.ErrorInfo;
  46 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  47 import org.openecomp.sdc.ci.tests.datatypes.expected.ExpectedCategoryAudit;
  48 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  49 import org.openecomp.sdc.ci.tests.utils.DbUtils;
  50 import org.openecomp.sdc.ci.tests.utils.Utils;
  51 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  52 import org.openecomp.sdc.ci.tests.utils.rest.CategoryRestUtils;
  53 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  54 import org.openecomp.sdc.ci.tests.utils.validation.AuditValidationUtils;
  55 import org.openecomp.sdc.ci.tests.utils.validation.CategoryValidationUtils;
  56 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  57 import org.testng.SkipException;
  58 import org.testng.annotations.BeforeMethod;
  59 import org.testng.annotations.Test;
  60
  61 public class GroupingTest extends CategoriesBaseTest {
  62
  63         protected static final String ADD_GROUPING = "AddGrouping";
  64         protected static final String CATEGORY = "category";
  65         protected static final String SUB_CATEGORY = "sub-category";
  66         protected static final String GROUPING = "grouping";
  67
  68         public GroupingTest() {
  69                 super(name, GroupingTest.class.getName());
  70         }
  71
  72         @Rule
  73         public static TestName name = new TestName();
  74
  75         private CategoryDefinition productCategoryDefinition;
  76         private CategoryDefinition productCategoryDefinition2;
  77
  78         private SubCategoryDefinition productSubCategoryDefinition;
  79         private SubCategoryDefinition productSubCategoryDefinition2;
  80         private SubCategoryDefinition productSubCategoryDefinition3;
  81
  82         private GroupingDefinition productGroupingDefinition;
  83         private GroupingDefinition productGroupingDefinition2;
  84         private GroupingDefinition productGroupingDefinition3;
  85
  86         @BeforeMethod
  87         public void init() throws Exception {
  88
  89                 // Category setup
  90                 productCategoryDefinition = new CategoryDefinition();
  91                 productCategoryDefinition.setName("Category1");
  92                 productCategoryDefinition2 = new CategoryDefinition();
  93                 productCategoryDefinition2.setName("Category2");
  94
  95                 // Subcategory setup
  96                 productSubCategoryDefinition = new SubCategoryDefinition();
  97                 productSubCategoryDefinition.setName("SubCategory1");
  98
  99                 productSubCategoryDefinition2 = new SubCategoryDefinition();
 100                 productSubCategoryDefinition2.setName("SubCategory2");
 101
 102                 productSubCategoryDefinition3 = new SubCategoryDefinition();
 103                 productSubCategoryDefinition3.setName("SubCategory1");
 104
 105                 // Group setup
 106                 productGroupingDefinition = new GroupingDefinition();
 107                 productGroupingDefinition.setName("Grouping1");
 108
 109                 productGroupingDefinition2 = new GroupingDefinition();
 110                 productGroupingDefinition2.setName("Grouping2");
 111
 112                 productGroupingDefinition3 = new GroupingDefinition();
 113                 productGroupingDefinition3.setName("Grouping1");
 114
 115                 // Init product category
 116                 RestResponse createCategory = CategoryRestUtils.createCategory(productCategoryDefinition,
 117                                 sdncProductStrategistUserDetails, PRODUCT_COMPONENT_TYPE);
 118                 assertEquals("Check response code after create category", STATUS_CODE_CREATED,
 119                                 createCategory.getErrorCode().intValue());
 120                 CategoryDefinition category = ResponseParser.parseToObject(createCategory.getResponse(),
 121                                 CategoryDefinition.class);
 122                 assertEquals("Check category name after creating category ", productCategoryDefinition.getName(),
 123                                 category.getName());
 124                 productCategoryDefinition = category;
 125
 126                 // Init product category1
 127                 createCategory = CategoryRestUtils.createCategory(productCategoryDefinition2, sdncProductStrategistUserDetails,
 128                                 PRODUCT_COMPONENT_TYPE);
 129                 assertEquals("Check response code after create category", STATUS_CODE_CREATED,
 130                                 createCategory.getErrorCode().intValue());
 131                 category = ResponseParser.parseToObject(createCategory.getResponse(), CategoryDefinition.class);
 132                 assertEquals("Check category name after creating category ", productCategoryDefinition2.getName(),
 133                                 category.getName());
 134                 productCategoryDefinition2 = category;
 135
 136                 // Init product productSubCategoryDefinition to
 137                 // productCategoryDefinition
 138                 RestResponse createSubCategory = CategoryRestUtils.createSubCategory(productSubCategoryDefinition,
 139                                 productCategoryDefinition, sdncProductStrategistUserDetails, PRODUCT_COMPONENT_TYPE);
 140                 assertEquals("Check response code after create category", STATUS_CODE_CREATED,
 141                                 createSubCategory.getErrorCode().intValue());
 142                 SubCategoryDefinition subCategory = ResponseParser.parseToObject(createSubCategory.getResponse(),
 143                                 SubCategoryDefinition.class);
 144                 assertEquals("Check category name after creating category ", productSubCategoryDefinition.getName(),
 145                                 subCategory.getName());
 146                 productSubCategoryDefinition = subCategory;
 147                 productCategoryDefinition.addSubCategory(productSubCategoryDefinition);
 148
 149                 // Init product productSubCategoryDefinition1 to
 150                 // productCategoryDefinition
 151                 createSubCategory = CategoryRestUtils.createSubCategory(productSubCategoryDefinition2,
 152                                 productCategoryDefinition, sdncProductStrategistUserDetails, PRODUCT_COMPONENT_TYPE);
 153                 assertEquals("Check response code after create category", STATUS_CODE_CREATED,
 154                                 createSubCategory.getErrorCode().intValue());
 155                 subCategory = ResponseParser.parseToObject(createSubCategory.getResponse(), SubCategoryDefinition.class);
 156                 assertEquals("Check category name after creating category ", productSubCategoryDefinition2.getName(),
 157                                 subCategory.getName());
 158                 productSubCategoryDefinition2 = subCategory;
 159                 productCategoryDefinition.addSubCategory(productSubCategoryDefinition2);
 160
 161                 // Init product productSubCategoryDefinition3 to
 162                 // productCategoryDefinition2
 163                 createSubCategory = CategoryRestUtils.createSubCategory(productSubCategoryDefinition3,
 164                                 productCategoryDefinition2, sdncProductStrategistUserDetails, PRODUCT_COMPONENT_TYPE);
 165                 assertEquals("Check response code after create category", STATUS_CODE_CREATED,
 166                                 createSubCategory.getErrorCode().intValue());
 167                 subCategory = ResponseParser.parseToObject(createSubCategory.getResponse(), SubCategoryDefinition.class);
 168                 assertEquals("Check category name after creating category ", productSubCategoryDefinition3.getName(),
 169                                 subCategory.getName());
 170                 productSubCategoryDefinition3 = subCategory;
 171                 productCategoryDefinition2.addSubCategory(productSubCategoryDefinition3);
 172         }
 173
 174         @Test
 175         public void createProductGroupCategorySuccess() throws Exception {
 176                 createGroupingSuccess(productGroupingDefinition, productSubCategoryDefinition, productCategoryDefinition,
 177                                 sdncProductStrategistUserDetails, PRODUCT_COMPONENT_TYPE, AUDIT_PRODUCT_TYPE);
 178         }
 179
 180         private void createGroupingSuccess(GroupingDefinition groupingDefinition,
 181                         SubCategoryDefinition subCategoryDefinition, CategoryDefinition categoryDefinition,
 182                         User sdncProductStrategistUserDetails, String productComponentType, String auditType) throws Exception {
 183
 184                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(groupingDefinition, subCategoryDefinition,
 185                                 categoryDefinition, sdncProductStrategistUserDetails, productComponentType);
 186                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 187                                 createGroupingRest.getErrorCode().intValue());
 188                 productGroupingDefinition.setNormalizedName("grouping1");
 189                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 190                                 productComponentType);
 191                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 192                                 getAllCategoriesRest.getErrorCode().intValue());
 193                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest, categoryDefinition.getUniqueId(),
 194                                 subCategoryDefinition.getUniqueId(), groupingDefinition);
 195
 196                 // Audit validation
 197                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, categoryDefinition, subCategoryDefinition,
 198                                 groupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, auditType);
 199         }
 200
 201         //// Benny
 202
 203         @Test
 204         public void createProductGroupByProductStrategist() throws Exception {
 205                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 206                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 207                                 PRODUCT_COMPONENT_TYPE);
 208                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 209                                 createGroupingRest.getErrorCode().intValue());
 210                 productGroupingDefinition.setNormalizedName("grouping1");
 211                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
 212
 213                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 214                                 PRODUCT_COMPONENT_TYPE);
 215                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 216                                 getAllCategoriesRest.getErrorCode().intValue());
 217                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 218                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 219                                 productGroupingDefinition);
 220                 // Audit validation
 221                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 222                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 223         }
 224
 225         @Test
 226         public void createProductGroupAlreadyExistInSameCategorySubCategory() throws Exception {
 227                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 228                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 229                                 PRODUCT_COMPONENT_TYPE);
 230                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 231                                 createGroupingRest.getErrorCode().intValue());
 232                 productGroupingDefinition.setNormalizedName("grouping1");
 233                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
 234                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 235                                 PRODUCT_COMPONENT_TYPE);
 236                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 237                                 getAllCategoriesRest.getErrorCode().intValue());
 238                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 239                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 240                                 productGroupingDefinition);
 241                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 242                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 243                 // Create Same Group already exist on same Category/SubCategory
 244                 DbUtils.deleteFromEsDbByPattern("_all");
 245                 createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition, productSubCategoryDefinition,
 246                                 productCategoryDefinition, sdncProductStrategistUserDetails, PRODUCT_COMPONENT_TYPE);
 247                 assertEquals("Check response code after create Sub category", STATUS_CODE_ALREADY_EXISTS,
 248                                 createGroupingRest.getErrorCode().intValue());
 249                 AuditValidationUtils.groupingAuditFailure(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 250                                 productGroupingDefinition, sdncProductStrategistUserDetails,
 251                                 ActionStatus.COMPONENT_GROUPING_EXISTS_FOR_SUB_CATEGORY, STATUS_CODE_ALREADY_EXISTS, AUDIT_PRODUCT_TYPE,
 252                                 AUDIT_PRODUCT_TYPE, productGroupingDefinition.getName(), productSubCategoryDefinition.getName());
 253         }
 254
 255         @Test
 256         public void createProductGroupUnderSameCategoryButDifferentSubCategory() throws Exception {
 257                 // Setting : Category-A, Sub-category-B , group : aBcd (display-Name :
 258                 // ABcd, normalized: abcd)  [A, B, ABcd]
 259                 // Action : Category-A, Sub-category-C, group : abcD (display-Name :
 260                 // ABcd, normalized: abcd)  [A, C, ABcd]
 261                 productGroupingDefinition.setName("ABCd");
 262                 productGroupingDefinition2.setName("abcD");
 263                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 264                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 265                                 PRODUCT_COMPONENT_TYPE);
 266                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 267                                 createGroupingRest.getErrorCode().intValue());
 268                 productGroupingDefinition.setNormalizedName("abcd");
 269                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
 270                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 271                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 272
 273                 DbUtils.deleteFromEsDbByPattern("_all");
 274                 createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition2, productSubCategoryDefinition2,
 275                                 productCategoryDefinition, sdncProductStrategistUserDetails, PRODUCT_COMPONENT_TYPE);
 276                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 277                                 createGroupingRest.getErrorCode().intValue());
 278                 productGroupingDefinition2.setName("ABCd");
 279                 productGroupingDefinition2.setNormalizedName("abcd");
 280                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition2);
 281                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition,
 282                                 productSubCategoryDefinition2, productGroupingDefinition2, sdncProductStrategistUserDetails,
 283                                 STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 284
 285                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 286                                 PRODUCT_COMPONENT_TYPE);
 287                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 288                                 getAllCategoriesRest.getErrorCode().intValue());
 289                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 290                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 291                                 productGroupingDefinition);
 292                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 293                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition2.getUniqueId(),
 294                                 productGroupingDefinition2);
 295         }
 296
 297         @Test
 298         public void createProductGroupUnderSameSubCategoryButDifferentCategory() throws Exception {
 299                 // Setting : Category-A, Sub-category-B , group : aBcd (display-Name :
 300                 // ABcd, normalized: abcd)  [A, B, ABcd]
 301                 // : Category-A, Sub-category-C, group : abcD (display-Name : ABcd,
 302                 // normalized: abcd)  [A, C, ABcd]
 303                 // : Category-K, Sub-category-B, group : abcD (display-Name : ABcd,
 304                 // normalized: abcd)  [K, B, ABcd]
 305                 productGroupingDefinition.setName("ABCd");
 306                 productGroupingDefinition2.setName("abcD");
 307                 productGroupingDefinition3.setName("aBCd");
 308                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 309                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 310                                 PRODUCT_COMPONENT_TYPE);
 311                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 312                                 createGroupingRest.getErrorCode().intValue());
 313                 productGroupingDefinition.setNormalizedName("abcd");
 314                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
 315                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 316                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 317
 318                 DbUtils.deleteFromEsDbByPattern("_all");
 319                 createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition2, productSubCategoryDefinition2,
 320                                 productCategoryDefinition, sdncProductStrategistUserDetails, PRODUCT_COMPONENT_TYPE);
 321                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 322                                 createGroupingRest.getErrorCode().intValue());
 323                 productGroupingDefinition2.setName("ABCd");
 324                 productGroupingDefinition2.setNormalizedName("abcd");
 325                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition2);
 326                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition,
 327                                 productSubCategoryDefinition2, productGroupingDefinition2, sdncProductStrategistUserDetails,
 328                                 STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 329                 DbUtils.deleteFromEsDbByPattern("_all");
 330                 createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition3, productSubCategoryDefinition3,
 331                                 productCategoryDefinition2, sdncProductStrategistUserDetails, PRODUCT_COMPONENT_TYPE);
 332                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 333                                 createGroupingRest.getErrorCode().intValue());
 334                 productGroupingDefinition3.setName("ABCd");
 335                 productGroupingDefinition3.setNormalizedName("abcd");
 336                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition3);
 337                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition2,
 338                                 productSubCategoryDefinition3, productGroupingDefinition3, sdncProductStrategistUserDetails,
 339                                 STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 340
 341                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 342                                 PRODUCT_COMPONENT_TYPE);
 343                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 344                                 getAllCategoriesRest.getErrorCode().intValue());
 345                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 346                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 347                                 productGroupingDefinition);
 348                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 349                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition2.getUniqueId(),
 350                                 productGroupingDefinition2);
 351                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 352                                 productCategoryDefinition2.getUniqueId(), productSubCategoryDefinition3.getUniqueId(),
 353                                 productGroupingDefinition3);
 354
 355         }
 356
 357         @Test
 358         public void createProductGroupsOnSameCategorySubCategory() throws Exception {
 359                 // Setting : Category-A, Sub-category-B , group : ABcd (display-Name :
 360                 // ABcd, normalized: abcd) [A ,B, ABcd]
 361                 // Action : Category-A, Sub-category-B, group : ZXcv (display-Name :
 362                 // ZXcv, normalized: zxcv) [A, B, ZXcv]
 363                 productGroupingDefinition.setName("ABcd");
 364                 productGroupingDefinition2.setName("ZXcv");
 365                 productGroupingDefinition2.setNormalizedName("zxcv");
 366                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 367                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 368                                 PRODUCT_COMPONENT_TYPE);
 369                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 370                                 createGroupingRest.getErrorCode().intValue());
 371                 productGroupingDefinition.setNormalizedName("abcd");
 372                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
 373                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 374                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 375
 376                 DbUtils.deleteFromEsDbByPattern("_all");
 377                 createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition2, productSubCategoryDefinition,
 378                                 productCategoryDefinition, sdncProductStrategistUserDetails, PRODUCT_COMPONENT_TYPE);
 379                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 380                                 createGroupingRest.getErrorCode().intValue());
 381                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition2);
 382                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 383                                 productGroupingDefinition2, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 384
 385                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 386                                 PRODUCT_COMPONENT_TYPE);
 387                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 388                                 getAllCategoriesRest.getErrorCode().intValue());
 389                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 390                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 391                                 productGroupingDefinition);
 392                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 393                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 394                                 productGroupingDefinition2);
 395         }
 396
 397         @Test
 398         public void createProductGroupUnderDifferentCategory() throws Exception {
 399                 // Setting : Category-A, Sub-category-B , group : aBcd (display-Name :
 400                 // ABcd, normalized: abcd) [A ,B, ABcd]
 401                 // Action : Category-K, Sub-category-B, group : abcD (display-Name :
 402                 // ABcd, normalized: abcd) [K, B, ABcd]
 403                 // productGroupingDefinition.setName("ABCd");
 404                 productGroupingDefinition.setName("ABcD");
 405                 productGroupingDefinition2.setName("abcD");
 406                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 407                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 408                                 PRODUCT_COMPONENT_TYPE);
 409                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 410                                 createGroupingRest.getErrorCode().intValue());
 411                 productGroupingDefinition.setNormalizedName("abcd");
 412                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
 413                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 414                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 415
 416                 DbUtils.deleteFromEsDbByPattern("_all");
 417                 createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition2, productSubCategoryDefinition3,
 418                                 productCategoryDefinition2, sdncProductStrategistUserDetails, PRODUCT_COMPONENT_TYPE);
 419                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 420                                 createGroupingRest.getErrorCode().intValue());
 421                 productGroupingDefinition2.setNormalizedName("abcd");
 422                 productGroupingDefinition2.setName("ABcD");
 423                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition2);
 424                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition2,
 425                                 productSubCategoryDefinition3, productGroupingDefinition2, sdncProductStrategistUserDetails,
 426                                 STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 427
 428                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 429                                 PRODUCT_COMPONENT_TYPE);
 430                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 431                                 getAllCategoriesRest.getErrorCode().intValue());
 432                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 433                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 434                                 productGroupingDefinition);
 435                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 436                                 productCategoryDefinition2.getUniqueId(), productSubCategoryDefinition3.getUniqueId(),
 437                                 productGroupingDefinition2);
 438         }
 439
 440         ///////////
 441         @Test
 442         public void createProductGroupByNonProductStrategist() throws Exception {
 443                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 444                                 productSubCategoryDefinition, productCategoryDefinition, sdncAdminUserDetails, PRODUCT_COMPONENT_TYPE);
 445                 assertEquals("Check response code after create product group", STATUS_CODE_RESTRICTED_OPERATION,
 446                                 createGroupingRest.getErrorCode().intValue());
 447                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 448                                 PRODUCT_COMPONENT_TYPE);
 449                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 450                                 getAllCategoriesRest.getErrorCode().intValue());
 451                 CategoryValidationUtils.verifyGroupingNotExistInGetResponse(getAllCategoriesRest,
 452                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 453                                 productGroupingDefinition);
 454                 // Audit validation
 455                 productCategoryDefinition.setName(productCategoryDefinition.getUniqueId());
 456                 productSubCategoryDefinition.setName(productSubCategoryDefinition.getUniqueId());
 457                 AuditValidationUtils.groupingAuditFailure(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 458                                 productGroupingDefinition, sdncAdminUserDetails, ActionStatus.RESTRICTED_OPERATION,
 459                                 STATUS_CODE_RESTRICTED_OPERATION, AUDIT_PRODUCT_TYPE);
 460         }
 461
 462         // @Ignore("DE176245")
 463         @Test
 464         public void createProductGroupForNonExistingComponentType() throws Exception {
 465                 String nonSupportedComponentType = "NonExistingComponentType"; // instead
 466                                                                                                                                                 // resource/product
 467                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 468                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 469                                 nonSupportedComponentType);
 470                 assertEquals("Check response code after create Sub category", STATUS_CODE_INVALID_CONTENT,
 471                                 createGroupingRest.getErrorCode().intValue());
 472                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 473                                 PRODUCT_COMPONENT_TYPE);
 474                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 475                                 getAllCategoriesRest.getErrorCode().intValue());
 476                 CategoryValidationUtils.verifyGroupingNotExistInGetResponse(getAllCategoriesRest,
 477                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 478                                 productGroupingDefinition);
 479                 // Audit validation
 480                 productCategoryDefinition.setName(productCategoryDefinition.getUniqueId());
 481                 productSubCategoryDefinition.setName(productSubCategoryDefinition.getUniqueId());
 482                 AuditValidationUtils.groupingAuditFailure(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 483                                 productGroupingDefinition, sdncProductStrategistUserDetails, ActionStatus.INVALID_CONTENT,
 484                                 STATUS_CODE_INVALID_CONTENT, nonSupportedComponentType);
 485         }
 486
 487         // @Ignore("DE176245")
 488         @Test
 489         public void createResourceGroup() throws Exception {
 490                 // Resource doesn't have group
 491                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 492                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 493                                 RESOURCE_COMPONENT_TYPE);
 494                 assertEquals("Check response code after create Sub category", STATUS_CODE_INVALID_CONTENT,
 495                                 createGroupingRest.getErrorCode().intValue());
 496                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 497                                 PRODUCT_COMPONENT_TYPE);
 498                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 499                                 getAllCategoriesRest.getErrorCode().intValue());
 500                 CategoryValidationUtils.verifyGroupingNotExistInGetResponse(getAllCategoriesRest,
 501                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 502                                 productGroupingDefinition);
 503                 // Audit validation
 504                 productCategoryDefinition.setName(productCategoryDefinition.getUniqueId());
 505                 productSubCategoryDefinition.setName(productSubCategoryDefinition.getUniqueId());
 506                 AuditValidationUtils.groupingAuditFailure(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 507                                 productGroupingDefinition, sdncProductStrategistUserDetails, ActionStatus.INVALID_CONTENT,
 508                                 STATUS_CODE_INVALID_CONTENT, AUDIT_RESOURCE_TYPE);
 509         }
 510
 511         // @Ignore("DE176245")
 512         @Test
 513         public void createServiceGroup() throws Exception {
 514                 // Service doesn't have group
 515                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 516                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 517                                 SERVICE_COMPONENT_TYPE);
 518                 assertEquals("Check response code after create Sub category", STATUS_CODE_INVALID_CONTENT,
 519                                 createGroupingRest.getErrorCode().intValue());
 520                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 521                                 PRODUCT_COMPONENT_TYPE);
 522                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 523                                 getAllCategoriesRest.getErrorCode().intValue());
 524                 CategoryValidationUtils.verifyGroupingNotExistInGetResponse(getAllCategoriesRest,
 525                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 526                                 productGroupingDefinition);
 527                 // Audit validation
 528                 productCategoryDefinition.setName(productCategoryDefinition.getUniqueId());
 529                 productSubCategoryDefinition.setName(productSubCategoryDefinition.getUniqueId());
 530                 AuditValidationUtils.groupingAuditFailure(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 531                                 productGroupingDefinition, sdncProductStrategistUserDetails, ActionStatus.INVALID_CONTENT,
 532                                 STATUS_CODE_INVALID_CONTENT, AUDIT_SERVICE_TYPE);
 533         }
 534
 535         @Test
 536         public void createProductGroupForNonExistingCategory() throws Exception {
 537
 538                 CategoryDefinition productCategoryDefinition100 = new CategoryDefinition();
 539                 productCategoryDefinition100.setName("category.nonexistingCategory");
 540                 productCategoryDefinition100.setUniqueId("category.nonexistingCategory");
 541                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 542                                 productSubCategoryDefinition, productCategoryDefinition100, sdncProductStrategistUserDetails,
 543                                 PRODUCT_COMPONENT_TYPE);
 544                 assertEquals("Check response code after create Sub category", STATUS_CODE_NOT_FOUND,
 545                                 createGroupingRest.getErrorCode().intValue());
 546                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 547                                 PRODUCT_COMPONENT_TYPE);
 548                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 549                                 getAllCategoriesRest.getErrorCode().intValue());
 550                 CategoryValidationUtils.verifyGroupingNotExistInGetResponse(getAllCategoriesRest,
 551                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 552                                 productGroupingDefinition);
 553                 // Audit validation
 554                 productSubCategoryDefinition.setName(productSubCategoryDefinition.getUniqueId());
 555                 AuditValidationUtils.groupingAuditFailure(ADD_GROUPING, productCategoryDefinition100,
 556                                 productSubCategoryDefinition, productGroupingDefinition, sdncProductStrategistUserDetails,
 557                                 ActionStatus.COMPONENT_CATEGORY_NOT_FOUND, STATUS_CODE_NOT_FOUND, AUDIT_PRODUCT_TYPE,
 558                                 PRODUCT_COMPONENT_TYPE, CATEGORY, "");
 559         }
 560
 561         @Test
 562         public void createProductGroupForNonExistingSunCategory() throws Exception {
 563                 throw new SkipException(
 564                                 "Skipping - failed in audit validation expected \"products\" actual result was \"product\" ");
 565                 // SubCategoryDefinition productSubCategoryDefinition100 = new
 566                 // SubCategoryDefinition();
 567                 // productSubCategoryDefinition100.setUniqueId("category.nonexistingSubCategory");
 568                 // RestResponse createGroupingRest =
 569                 // CategoryRestUtils.createGrouping(productGroupingDefinition,
 570                 // productSubCategoryDefinition100, productCategoryDefinition,
 571                 // sdncProductStrategistUserDetails, PRODUCT_COMPONENT_TYPE);
 572                 // assertEquals("Check response code after create Sub category",
 573                 // STATUS_CODE_NOT_FOUND, createGroupingRest.getErrorCode().intValue());
 574                 // RestResponse getAllCategoriesRest =
 575                 // CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 576                 // PRODUCT_COMPONENT_TYPE);
 577                 // assertEquals("Check response code after get all categories ",
 578                 // STATUS_CODE_SUCCESS, getAllCategoriesRest.getErrorCode().intValue());
 579                 // CategoryValidationUtils.verifyGroupingNotExistInGetResponse(getAllCategoriesRest,
 580                 // productCategoryDefinition.getUniqueId(),
 581                 // productSubCategoryDefinition.getUniqueId(),
 582                 // productGroupingDefinition);
 583                 // //Audit validation
 584                 // productSubCategoryDefinition100.setName(productSubCategoryDefinition100.getUniqueId());
 585                 // AuditValidationUtils.groupingAuditFailure(ADD_GROUPING ,
 586                 // productCategoryDefinition, productSubCategoryDefinition100,
 587                 // productGroupingDefinition, sdncProductStrategistUserDetails,
 588                 // ActionStatus.COMPONENT_CATEGORY_NOT_FOUND,
 589                 // STATUS_CODE_NOT_FOUND,AUDIT_PRODUCT_TYPE, PRODUCT_COMPONENT_TYPE,
 590                 // SUB_CATEGORY, "");
 591         }
 592
 593         @Test
 594         public void ProductGroupAllowedcharacters_01() throws Exception {
 595                 productGroupingDefinition.setName("1234AbcdE-");
 596                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 597                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 598                                 PRODUCT_COMPONENT_TYPE);
 599                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 600                                 createGroupingRest.getErrorCode().intValue());
 601                 productGroupingDefinition.setNormalizedName("1234abcde-");
 602                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
 603                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 604                                 PRODUCT_COMPONENT_TYPE);
 605                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 606                                 getAllCategoriesRest.getErrorCode().intValue());
 607                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 608                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 609                                 productGroupingDefinition);
 610                 // Audit validation
 611                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 612                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 613         }
 614
 615         @Test
 616         public void ProductGroupAllowedcharacters_02() throws Exception {
 617                 productGroupingDefinition.setName("1234AbcdE+");
 618                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 619                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 620                                 PRODUCT_COMPONENT_TYPE);
 621                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 622                                 createGroupingRest.getErrorCode().intValue());
 623                 productGroupingDefinition.setNormalizedName("1234abcde+");
 624                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
 625                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 626                                 PRODUCT_COMPONENT_TYPE);
 627                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 628                                 getAllCategoriesRest.getErrorCode().intValue());
 629                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 630                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 631                                 productGroupingDefinition);
 632                 // Audit validation
 633                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 634                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 635         }
 636
 637         @Test
 638         public void ProductGroupAllowedcharacters_03() throws Exception {
 639                 productGroupingDefinition.setName("1234AbcdE&");
 640                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 641                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 642                                 PRODUCT_COMPONENT_TYPE);
 643                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 644                                 createGroupingRest.getErrorCode().intValue());
 645                 productGroupingDefinition.setNormalizedName("1234abcde&");
 646                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
 647                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 648                                 PRODUCT_COMPONENT_TYPE);
 649                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 650                                 getAllCategoriesRest.getErrorCode().intValue());
 651                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 652                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 653                                 productGroupingDefinition);
 654                 // Audit validation
 655                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 656                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 657         }
 658
 659         @Test
 660         public void ProductGroupAllowedcharacters_04() throws Exception {
 661                 productGroupingDefinition.setName("1234AbcdE-");
 662                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 663                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 664                                 PRODUCT_COMPONENT_TYPE);
 665                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 666                                 createGroupingRest.getErrorCode().intValue());
 667                 productGroupingDefinition.setNormalizedName("1234abcde-");
 668                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
 669                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 670                                 PRODUCT_COMPONENT_TYPE);
 671                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 672                                 getAllCategoriesRest.getErrorCode().intValue());
 673                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 674                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 675                                 productGroupingDefinition);
 676                 // Audit validation
 677                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 678                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 679         }
 680
 681         @Test
 682         public void ProductGroupAllowedcharacters_05() throws Exception {
 683                 productGroupingDefinition.setName("1234AbcdE+");
 684                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 685                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 686                                 PRODUCT_COMPONENT_TYPE);
 687                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 688                                 createGroupingRest.getErrorCode().intValue());
 689                 productGroupingDefinition.setNormalizedName("1234abcde+");
 690                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
 691                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 692                                 PRODUCT_COMPONENT_TYPE);
 693                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 694                                 getAllCategoriesRest.getErrorCode().intValue());
 695                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 696                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 697                                 productGroupingDefinition);
 698                 // Audit validation
 699                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 700                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 701         }
 702
 703         @Test
 704         public void ProductGroupAllowedcharacters_06() throws Exception {
 705                 productGroupingDefinition.setName("1234AbcdE.");
 706                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 707                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 708                                 PRODUCT_COMPONENT_TYPE);
 709                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 710                                 createGroupingRest.getErrorCode().intValue());
 711                 productGroupingDefinition.setNormalizedName("1234abcde.");
 712                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
 713                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 714                                 PRODUCT_COMPONENT_TYPE);
 715                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 716                                 getAllCategoriesRest.getErrorCode().intValue());
 717                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 718                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 719                                 productGroupingDefinition);
 720                 // Audit validation
 721                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 722                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 723         }
 724
 725         @Test
 726         public void ProductGroupAllowedcharacters_07() throws Exception {
 727                 productGroupingDefinition.setName("1234AbcdE'");
 728                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 729                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 730                                 PRODUCT_COMPONENT_TYPE);
 731                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 732                                 createGroupingRest.getErrorCode().intValue());
 733                 productGroupingDefinition.setNormalizedName("1234abcde'");
 734                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
 735                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 736                                 PRODUCT_COMPONENT_TYPE);
 737                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 738                                 getAllCategoriesRest.getErrorCode().intValue());
 739                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 740                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 741                                 productGroupingDefinition);
 742                 // Audit validation
 743                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 744                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 745         }
 746
 747         @Test
 748         public void ProductGroupAllowedcharacters_08() throws Exception {
 749                 productGroupingDefinition.setName("1234AbcdE=");
 750                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 751                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 752                                 PRODUCT_COMPONENT_TYPE);
 753                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 754                                 createGroupingRest.getErrorCode().intValue());
 755                 productGroupingDefinition.setNormalizedName("1234abcde=");
 756                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
 757                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 758                                 PRODUCT_COMPONENT_TYPE);
 759                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 760                                 getAllCategoriesRest.getErrorCode().intValue());
 761                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 762                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 763                                 productGroupingDefinition);
 764                 // Audit validation
 765                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 766                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 767         }
 768
 769         @Test
 770         public void ProductGroupAllowedcharacters_09() throws Exception {
 771                 productGroupingDefinition.setName("1234AbcdE:");
 772                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 773                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 774                                 PRODUCT_COMPONENT_TYPE);
 775                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 776                                 createGroupingRest.getErrorCode().intValue());
 777                 productGroupingDefinition.setNormalizedName("1234abcde:");
 778                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
 779                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 780                                 PRODUCT_COMPONENT_TYPE);
 781                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 782                                 getAllCategoriesRest.getErrorCode().intValue());
 783                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 784                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 785                                 productGroupingDefinition);
 786                 // Audit validation
 787                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 788                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 789         }
 790
 791         @Test
 792         public void ProductGroupAllowedcharacters_10() throws Exception {
 793                 productGroupingDefinition.setName("1234AbcdE@");
 794                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 795                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 796                                 PRODUCT_COMPONENT_TYPE);
 797                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 798                                 createGroupingRest.getErrorCode().intValue());
 799                 productGroupingDefinition.setNormalizedName("1234abcde@");
 800                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
 801                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 802                                 PRODUCT_COMPONENT_TYPE);
 803                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 804                                 getAllCategoriesRest.getErrorCode().intValue());
 805                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 806                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 807                                 productGroupingDefinition);
 808                 // Audit validation
 809                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 810                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 811         }
 812
 813         @Test
 814         public void ProductGroupAllowedcharacters_11() throws Exception {
 815                 productGroupingDefinition.setName("1234AbcdE_");
 816                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 817                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 818                                 PRODUCT_COMPONENT_TYPE);
 819                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 820                                 createGroupingRest.getErrorCode().intValue());
 821                 productGroupingDefinition.setNormalizedName("1234abcde_");
 822                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
 823                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 824                                 PRODUCT_COMPONENT_TYPE);
 825                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 826                                 getAllCategoriesRest.getErrorCode().intValue());
 827                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 828                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 829                                 productGroupingDefinition);
 830                 // Audit validation
 831                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 832                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 833         }
 834
 835         @Test
 836         public void ProductGroupAllowedcharacters_12() throws Exception {
 837                 productGroupingDefinition.setName("1234AbcdE#");
 838                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 839                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 840                                 PRODUCT_COMPONENT_TYPE);
 841                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 842                                 createGroupingRest.getErrorCode().intValue());
 843                 productGroupingDefinition.setNormalizedName("1234abcde#");
 844                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
 845                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 846                                 PRODUCT_COMPONENT_TYPE);
 847                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 848                                 getAllCategoriesRest.getErrorCode().intValue());
 849                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 850                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 851                                 productGroupingDefinition);
 852                 // Audit validation
 853                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 854                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 855         }
 856
 857         @Test
 858         public void ProductGroupAllowedcharacters_13() throws Exception {
 859                 productGroupingDefinition.setName("1234AbcdE d");
 860                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 861                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 862                                 PRODUCT_COMPONENT_TYPE);
 863                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 864                                 createGroupingRest.getErrorCode().intValue());
 865                 productGroupingDefinition.setName("1234AbcdE D");
 866                 productGroupingDefinition.setNormalizedName("1234abcde d");
 867                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
 868                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 869                                 PRODUCT_COMPONENT_TYPE);
 870                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 871                                 getAllCategoriesRest.getErrorCode().intValue());
 872                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 873                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 874                                 productGroupingDefinition);
 875                 // Audit validation
 876                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 877                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 878         }
 879
 880         @Test
 881         public void groupNameValidation_RemoveSpaceFromBeginning() throws Exception {
 882                 productGroupingDefinition.setName("  Category01");
 883                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 884                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 885                                 PRODUCT_COMPONENT_TYPE);
 886                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 887                                 createGroupingRest.getErrorCode().intValue());
 888                 productGroupingDefinition.setNormalizedName("category01");
 889                 productGroupingDefinition.setName("Category01");
 890                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
 891                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 892                                 PRODUCT_COMPONENT_TYPE);
 893                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 894                                 getAllCategoriesRest.getErrorCode().intValue());
 895                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 896                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 897                                 productGroupingDefinition);
 898                 // Audit validation
 899                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 900                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 901         }
 902
 903         @Test
 904         public void groupNameValidation_RemoveSpaceFromEnd() throws Exception {
 905                 productGroupingDefinition.setName("Category01    ");
 906                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 907                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 908                                 PRODUCT_COMPONENT_TYPE);
 909                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 910                                 createGroupingRest.getErrorCode().intValue());
 911                 productGroupingDefinition.setNormalizedName("category01");
 912                 productGroupingDefinition.setName("Category01");
 913                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
 914                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 915                                 PRODUCT_COMPONENT_TYPE);
 916                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 917                                 getAllCategoriesRest.getErrorCode().intValue());
 918                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 919                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 920                                 productGroupingDefinition);
 921                 // Audit validation
 922                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 923                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 924         }
 925
 926         @Test
 927         public void groupNameValidation_RemoveExtraSpace() throws Exception {
 928                 productGroupingDefinition.setName("Category    02");
 929                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 930                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 931                                 PRODUCT_COMPONENT_TYPE);
 932                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 933                                 createGroupingRest.getErrorCode().intValue());
 934                 productGroupingDefinition.setNormalizedName("category 02");
 935                 productGroupingDefinition.setName("Category 02");
 936                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
 937                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 938                                 PRODUCT_COMPONENT_TYPE);
 939                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 940                                 getAllCategoriesRest.getErrorCode().intValue());
 941                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 942                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 943                                 productGroupingDefinition);
 944                 // Audit validation
 945                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 946                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 947         }
 948
 949         @Test
 950         public void groupNameValidation_RemoveExtraAmpersand() throws Exception {
 951                 productGroupingDefinition.setName("Category&& &02");
 952                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 953                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 954                                 PRODUCT_COMPONENT_TYPE);
 955                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 956                                 createGroupingRest.getErrorCode().intValue());
 957                 productGroupingDefinition.setNormalizedName("category& &02");
 958                 productGroupingDefinition.setName("Category& &02");
 959                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
 960                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 961                                 PRODUCT_COMPONENT_TYPE);
 962                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 963                                 getAllCategoriesRest.getErrorCode().intValue());
 964                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 965                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 966                                 productGroupingDefinition);
 967                 // Audit validation
 968                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 969                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 970         }
 971
 972         @Test
 973         public void groupNameValidation_RemoveExtraDash() throws Exception {
 974                 productGroupingDefinition.setName("CategorY-- --02");
 975                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 976                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
 977                                 PRODUCT_COMPONENT_TYPE);
 978                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
 979                                 createGroupingRest.getErrorCode().intValue());
 980                 productGroupingDefinition.setNormalizedName("category- -02");
 981                 productGroupingDefinition.setName("CategorY- -02");
 982                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
 983                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
 984                                 PRODUCT_COMPONENT_TYPE);
 985                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
 986                                 getAllCategoriesRest.getErrorCode().intValue());
 987                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
 988                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
 989                                 productGroupingDefinition);
 990                 // Audit validation
 991                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
 992                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
 993         }
 994
 995         @Test
 996         public void groupNameValidation_RemoveExtraPlus() throws Exception {
 997                 productGroupingDefinition.setName("CateGory++++ +02");
 998                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
 999                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1000                                 PRODUCT_COMPONENT_TYPE);
1001                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1002                                 createGroupingRest.getErrorCode().intValue());
1003                 productGroupingDefinition.setName("CateGory+ +02");
1004                 productGroupingDefinition.setNormalizedName("category+ +02");
1005                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1006                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1007                                 PRODUCT_COMPONENT_TYPE);
1008                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1009                                 getAllCategoriesRest.getErrorCode().intValue());
1010                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1011                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1012                                 productGroupingDefinition);
1013                 // Audit validation
1014                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1015                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1016         }
1017
1018         @Test
1019         public void groupNameValidation_RemoveExtraPeriod() throws Exception {
1020                 productGroupingDefinition.setName("Category.... .02");
1021                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1022                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1023                                 PRODUCT_COMPONENT_TYPE);
1024                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1025                                 createGroupingRest.getErrorCode().intValue());
1026                 productGroupingDefinition.setName("Category. .02");
1027                 productGroupingDefinition.setNormalizedName("category. .02");
1028                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1029                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1030                                 PRODUCT_COMPONENT_TYPE);
1031                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1032                                 getAllCategoriesRest.getErrorCode().intValue());
1033                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1034                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1035                                 productGroupingDefinition);
1036                 // Audit validation
1037                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1038                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1039         }
1040
1041         @Test
1042         public void groupNameValidation_RemoveExtraApostrophe() throws Exception {
1043                 productGroupingDefinition.setName("CaTegory''' '02");
1044                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1045                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1046                                 PRODUCT_COMPONENT_TYPE);
1047                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1048                                 createGroupingRest.getErrorCode().intValue());
1049                 productGroupingDefinition.setName("CaTegory' '02");
1050                 productGroupingDefinition.setNormalizedName("category' '02");
1051                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1052                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1053                                 PRODUCT_COMPONENT_TYPE);
1054                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1055                                 getAllCategoriesRest.getErrorCode().intValue());
1056                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1057                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1058                                 productGroupingDefinition);
1059                 // Audit validation
1060                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1061                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1062         }
1063
1064         @Test
1065         public void groupNameValidation_RemoveExtraHashtag() throws Exception {
1066                 productGroupingDefinition.setName("Category### #02");
1067                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1068                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1069                                 PRODUCT_COMPONENT_TYPE);
1070                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1071                                 createGroupingRest.getErrorCode().intValue());
1072                 productGroupingDefinition.setName("Category# #02");
1073                 productGroupingDefinition.setNormalizedName("category# #02");
1074                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1075                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1076                                 PRODUCT_COMPONENT_TYPE);
1077                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1078                                 getAllCategoriesRest.getErrorCode().intValue());
1079                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1080                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1081                                 productGroupingDefinition);
1082                 // Audit validation
1083                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1084                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1085         }
1086
1087         @Test
1088         public void groupNameValidation_RemoveExtrEequal() throws Exception {
1089                 productGroupingDefinition.setName("Category=== =02");
1090                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1091                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1092                                 PRODUCT_COMPONENT_TYPE);
1093                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1094                                 createGroupingRest.getErrorCode().intValue());
1095                 productGroupingDefinition.setName("Category= =02");
1096                 productGroupingDefinition.setNormalizedName("category= =02");
1097                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1098                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1099                                 PRODUCT_COMPONENT_TYPE);
1100                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1101                                 getAllCategoriesRest.getErrorCode().intValue());
1102                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1103                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1104                                 productGroupingDefinition);
1105                 // Audit validation
1106                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1107                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1108         }
1109
1110         @Test
1111         public void groupNameValidation_RemoveExtrColon() throws Exception {
1112                 productGroupingDefinition.setName("Category::: :02");
1113                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1114                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1115                                 PRODUCT_COMPONENT_TYPE);
1116                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1117                                 createGroupingRest.getErrorCode().intValue());
1118                 productGroupingDefinition.setName("Category: :02");
1119                 productGroupingDefinition.setNormalizedName("category: :02");
1120                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1121                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1122                                 PRODUCT_COMPONENT_TYPE);
1123                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1124                                 getAllCategoriesRest.getErrorCode().intValue());
1125                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1126                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1127                                 productGroupingDefinition);
1128                 // Audit validation
1129                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1130                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1131         }
1132
1133         @Test
1134         public void groupNameValidation_RemoveExtrAt() throws Exception {
1135                 productGroupingDefinition.setName("Category@@@ @a2");
1136                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1137                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1138                                 PRODUCT_COMPONENT_TYPE);
1139                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1140                                 createGroupingRest.getErrorCode().intValue());
1141                 productGroupingDefinition.setName("Category@ @a2");
1142                 productGroupingDefinition.setNormalizedName("category@ @a2");
1143                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1144                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1145                                 PRODUCT_COMPONENT_TYPE);
1146                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1147                                 getAllCategoriesRest.getErrorCode().intValue());
1148                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1149                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1150                                 productGroupingDefinition);
1151                 // Audit validation
1152                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1153                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1154         }
1155
1156         @Test
1157         public void groupNameValidation_RemoveExtraUnderscore() throws Exception {
1158                 productGroupingDefinition.setName("Category___ _22");
1159                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1160                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1161                                 PRODUCT_COMPONENT_TYPE);
1162                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1163                                 createGroupingRest.getErrorCode().intValue());
1164                 productGroupingDefinition.setName("Category_ _22");
1165                 productGroupingDefinition.setNormalizedName("category_ _22");
1166                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1167                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1168                                 PRODUCT_COMPONENT_TYPE);
1169                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1170                                 getAllCategoriesRest.getErrorCode().intValue());
1171                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1172                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1173                                 productGroupingDefinition);
1174                 // Audit validation
1175                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1176                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1177         }
1178
1179         @Test
1180         public void groupNameValidation_FirstWordStartWithNumber() throws Exception {
1181                 productGroupingDefinition.setName("1Category one");
1182                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1183                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1184                                 PRODUCT_COMPONENT_TYPE);
1185                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1186                                 createGroupingRest.getErrorCode().intValue());
1187                 productGroupingDefinition.setName("1Category One");
1188                 productGroupingDefinition.setNormalizedName("1category one");
1189                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1190                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1191                                 PRODUCT_COMPONENT_TYPE);
1192                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1193                                 getAllCategoriesRest.getErrorCode().intValue());
1194                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1195                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1196                                 productGroupingDefinition);
1197                 // Audit validation
1198                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1199                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1200         }
1201
1202         @Test
1203         public void groupNameValidation_FirstWordStartWithNonAlphaNumeric() throws Exception { // The
1204                                                                                                                                                                                         // first
1205                                                                                                                                                                                         // word
1206                                                                                                                                                                                         // must
1207                                                                                                                                                                                         // start
1208                                                                                                                                                                                         // with
1209                                                                                                                                                                                         // an
1210                                                                                                                                                                                         // alpha-numeric
1211                                                                                                                                                                                         // character
1212                                                                                                                                                                                         // [a-Z
1213                                                                                                                                                                                         // A..Z,
1214                                                                                                                                                                                         // 0..9]
1215                 char invalidChars[] = { '&', '-', '+', '.', '\'', '#', '=', ':', '@', '_' };
1216                 RestResponse createGroupingRest;
1217                 RestResponse getAllCategoriesRest;
1218                 for (int i = 0; i < invalidChars.length; i++) {
1219                         DbUtils.deleteFromEsDbByPattern("_all");
1220                         productGroupingDefinition.setName(invalidChars[i] + "AbcD123");
1221                         productGroupingDefinition.setNormalizedName((invalidChars[i] + "AbcD123").toLowerCase());
1222                         createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1223                                         productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1224                                         PRODUCT_COMPONENT_TYPE);
1225                         assertEquals("Check response code after create Category", STATUS_CODE_INVALID_CONTENT,
1226                                         createGroupingRest.getErrorCode().intValue());
1227
1228                         getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails, PRODUCT_COMPONENT_TYPE);
1229                         assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1230                                         getAllCategoriesRest.getErrorCode().intValue());
1231                         CategoryValidationUtils.verifyGroupingNotExistInGetResponse(getAllCategoriesRest,
1232                                         productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1233                                         productGroupingDefinition);
1234                 }
1235         }
1236
1237         @Test
1238         public void groupNameValidation_ReplaceAndWithAmpersand_01() throws Exception {
1239                 productGroupingDefinition.setName("At and T");
1240                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1241                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1242                                 PRODUCT_COMPONENT_TYPE);
1243                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1244                                 createGroupingRest.getErrorCode().intValue());
1245                 productGroupingDefinition.setName("At & T");
1246                 productGroupingDefinition.setNormalizedName("at & t");
1247                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1248                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1249                                 PRODUCT_COMPONENT_TYPE);
1250                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1251                                 getAllCategoriesRest.getErrorCode().intValue());
1252                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1253                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1254                                 productGroupingDefinition);
1255                 // Audit validation
1256                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1257                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1258         }
1259
1260         @Test
1261         public void groupNameValidation_ReplaceAndWithAmpersand_02() throws Exception {
1262                 productGroupingDefinition.setName("At and t");
1263                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1264                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1265                                 PRODUCT_COMPONENT_TYPE);
1266                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1267                                 createGroupingRest.getErrorCode().intValue());
1268                 productGroupingDefinition.setName("At & T");
1269                 productGroupingDefinition.setNormalizedName("at & t");
1270                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1271                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1272                                 PRODUCT_COMPONENT_TYPE);
1273                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1274                                 getAllCategoriesRest.getErrorCode().intValue());
1275                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1276                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1277                                 productGroupingDefinition);
1278                 // Audit validation
1279                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1280                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1281         }
1282
1283         @Test
1284         public void groupNameValidation_ReplaceAndWithAmpersand_03() throws Exception {
1285                 productGroupingDefinition.setName("Atand T");
1286                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1287                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1288                                 PRODUCT_COMPONENT_TYPE);
1289                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1290                                 createGroupingRest.getErrorCode().intValue());
1291                 productGroupingDefinition.setNormalizedName("atand t");
1292                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1293                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1294                                 PRODUCT_COMPONENT_TYPE);
1295                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1296                                 getAllCategoriesRest.getErrorCode().intValue());
1297                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1298                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1299                                 productGroupingDefinition);
1300                 // Audit validation
1301                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1302                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1303         }
1304
1305         @Test
1306         public void groupNameValidation_ReplaceAndWithAmpersand_04() throws Exception {
1307                 productGroupingDefinition.setName("At andT");
1308                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1309                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1310                                 PRODUCT_COMPONENT_TYPE);
1311                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1312                                 createGroupingRest.getErrorCode().intValue());
1313                 productGroupingDefinition.setNormalizedName("at andt");
1314                 productGroupingDefinition.setName("At AndT");
1315                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1316                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1317                                 PRODUCT_COMPONENT_TYPE);
1318                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1319                                 getAllCategoriesRest.getErrorCode().intValue());
1320                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1321                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1322                                 productGroupingDefinition);
1323                 // Audit validation
1324                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1325                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1326         }
1327
1328         @Test
1329         public void groupNameValidation_ReplaceAndWithAmpersand_05() throws Exception {
1330                 productGroupingDefinition.setName(" and AttT");
1331                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1332                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1333                                 PRODUCT_COMPONENT_TYPE);
1334                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1335                                 createGroupingRest.getErrorCode().intValue());
1336                 productGroupingDefinition.setNormalizedName("and attt");
1337                 productGroupingDefinition.setName("And AttT");
1338                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1339                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1340                                 PRODUCT_COMPONENT_TYPE);
1341                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1342                                 getAllCategoriesRest.getErrorCode().intValue());
1343                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1344                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1345                                 productGroupingDefinition);
1346                 // Audit validation
1347                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1348                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1349         }
1350
1351         @Test
1352         public void groupNameValidation_ReplaceAndWithAmpersand_06() throws Exception {
1353                 productGroupingDefinition.setName("AttT and ");
1354                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1355                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1356                                 PRODUCT_COMPONENT_TYPE);
1357                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1358                                 createGroupingRest.getErrorCode().intValue());
1359                 productGroupingDefinition.setNormalizedName("attt and");
1360                 productGroupingDefinition.setName("AttT And");
1361                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1362                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1363                                 PRODUCT_COMPONENT_TYPE);
1364                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1365                                 getAllCategoriesRest.getErrorCode().intValue());
1366                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1367                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1368                                 productGroupingDefinition);
1369                 // Audit validation
1370                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1371                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1372         }
1373
1374         @Test
1375         public void groupNameValidation_ReplaceAndWithAmpersand_07() throws Exception {
1376                 productGroupingDefinition.setName(" and a");
1377                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1378                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1379                                 PRODUCT_COMPONENT_TYPE);
1380                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1381                                 createGroupingRest.getErrorCode().intValue());
1382                 productGroupingDefinition.setNormalizedName("and a");
1383                 productGroupingDefinition.setName("And a");
1384                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1385                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1386                                 PRODUCT_COMPONENT_TYPE);
1387                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1388                                 getAllCategoriesRest.getErrorCode().intValue());
1389                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1390                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1391                                 productGroupingDefinition);
1392                 // Audit validation
1393                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1394                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1395         }
1396
1397         @Test
1398         public void groupNameValidationMaxLength() throws Exception {
1399                 productGroupingDefinition.setName("AsdfghjQ234567890@#.&:+-_");
1400                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1401                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1402                                 PRODUCT_COMPONENT_TYPE);
1403                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1404                                 createGroupingRest.getErrorCode().intValue());
1405                 productGroupingDefinition.setNormalizedName("asdfghjq234567890@#.&:+-_");
1406                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1407                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1408                                 PRODUCT_COMPONENT_TYPE);
1409                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1410                                 getAllCategoriesRest.getErrorCode().intValue());
1411                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1412                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1413                                 productGroupingDefinition);
1414                 // Audit validation
1415                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1416                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1417         }
1418
1419         @Test
1420         public void groupNameValidationMaxLengthAfterNormalization() throws Exception {
1421                 productGroupingDefinition.setName("  A jQ234 @@@___ +++ At and T and and ");
1422                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1423                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1424                                 PRODUCT_COMPONENT_TYPE);
1425                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1426                                 createGroupingRest.getErrorCode().intValue());
1427                 productGroupingDefinition.setNormalizedName("a jq234 @_ + at & t & and");
1428                 productGroupingDefinition.setName("A JQ234 @_ + At & T & And");
1429                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1430                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1431                                 PRODUCT_COMPONENT_TYPE);
1432                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1433                                 getAllCategoriesRest.getErrorCode().intValue());
1434                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1435                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1436                                 productGroupingDefinition);
1437                 // Audit validation
1438                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1439                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1440         }
1441
1442         @Test
1443         public void groupNameValidationExceedMaxLengthAfterNormalization() throws Exception {
1444                 productGroupingDefinition.setName("  AbdfghBCVa jQ234 @@___ +++ At and T   ");
1445                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1446                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1447                                 PRODUCT_COMPONENT_TYPE);
1448                 assertEquals("Check response code after create product group", STATUS_CODE_INVALID_CONTENT,
1449                                 createGroupingRest.getErrorCode().intValue());
1450                 productGroupingDefinition.setNormalizedName("abdfghbcva jq234 @_ + at&t");
1451                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1452                                 PRODUCT_COMPONENT_TYPE);
1453                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1454                                 getAllCategoriesRest.getErrorCode().intValue());
1455                 CategoryValidationUtils.verifyGroupingNotExistInGetResponse(getAllCategoriesRest,
1456                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1457                                 productGroupingDefinition);
1458                 // Audit validation
1459                 AuditValidationUtils.groupingAuditFailure(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1460                                 productGroupingDefinition, sdncProductStrategistUserDetails,
1461                                 ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_LENGTH, STATUS_CODE_INVALID_CONTENT, AUDIT_PRODUCT_TYPE,
1462                                 AUDIT_PRODUCT_TYPE, GROUPING);
1463         }
1464
1465         @Test
1466         public void groupNameValidationMinLengthAfterNormalization() throws Exception {
1467                 productGroupingDefinition.setName("  At&&&&&&&&&&&&t   ");
1468                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1469                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1470                                 PRODUCT_COMPONENT_TYPE);
1471                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1472                                 createGroupingRest.getErrorCode().intValue());
1473                 productGroupingDefinition.setNormalizedName("at&t");
1474                 productGroupingDefinition.setName("At&t");
1475                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1476                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1477                                 PRODUCT_COMPONENT_TYPE);
1478                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1479                                 getAllCategoriesRest.getErrorCode().intValue());
1480                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1481                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1482                                 productGroupingDefinition);
1483                 // Audit validation
1484                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1485                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1486         }
1487
1488         @Test
1489         public void groupNameValidationLessThanMinLengthAfterNormalization() throws Exception {
1490                 productGroupingDefinition.setName("  A&&&&&&&&&&&&T   ");
1491                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1492                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1493                                 PRODUCT_COMPONENT_TYPE);
1494                 assertEquals("Check response code after create product group", STATUS_CODE_INVALID_CONTENT,
1495                                 createGroupingRest.getErrorCode().intValue());
1496                 productGroupingDefinition.setNormalizedName("a&t");
1497                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1498                                 PRODUCT_COMPONENT_TYPE);
1499                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1500                                 getAllCategoriesRest.getErrorCode().intValue());
1501                 CategoryValidationUtils.verifyGroupingNotExistInGetResponse(getAllCategoriesRest,
1502                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1503                                 productGroupingDefinition);
1504                 // Audit validation
1505                 AuditValidationUtils.groupingAuditFailure(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1506                                 productGroupingDefinition, sdncProductStrategistUserDetails,
1507                                 ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_LENGTH, STATUS_CODE_INVALID_CONTENT, AUDIT_PRODUCT_TYPE,
1508                                 AUDIT_PRODUCT_TYPE, GROUPING);
1509         }
1510
1511         @Test
1512         public void groupNameValidationIsEmpty() throws Exception {
1513                 productGroupingDefinition.setName("");
1514                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1515                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1516                                 PRODUCT_COMPONENT_TYPE);
1517                 assertEquals("Check response code after create product group", STATUS_CODE_INVALID_CONTENT,
1518                                 createGroupingRest.getErrorCode().intValue());
1519                 productGroupingDefinition.setNormalizedName("");
1520                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1521                                 PRODUCT_COMPONENT_TYPE);
1522                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1523                                 getAllCategoriesRest.getErrorCode().intValue());
1524                 CategoryValidationUtils.verifyGroupingNotExistInGetResponse(getAllCategoriesRest,
1525                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1526                                 productGroupingDefinition);
1527                 // Audit validation
1528                 AuditValidationUtils.groupingAuditFailure(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1529                                 productGroupingDefinition, sdncProductStrategistUserDetails,
1530                                 ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_FORMAT, STATUS_CODE_INVALID_CONTENT, AUDIT_PRODUCT_TYPE,
1531                                 AUDIT_PRODUCT_TYPE, GROUPING);
1532         }
1533
1534         @Test
1535         public void groupNameValidationInvalidCharacters() throws Exception {
1536                 RestResponse createGroupingRest;
1537                 RestResponse getAllCategoriesRest;
1538                 char invalidChars[] = { '~', '!', '$', '%', '^', '*', '(', ')', '"', '{', '}', '[', ']', '?', '>', '<', '/',
1539                                 '|', '\\', ',' };
1540                 for (int i = 0; i < invalidChars.length; i++) {
1541                         DbUtils.deleteFromEsDbByPattern("_all");
1542                         productGroupingDefinition.setName("AbcD123" + invalidChars[i]);
1543                         createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1544                                         productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1545                                         PRODUCT_COMPONENT_TYPE);
1546                         assertEquals("Check response code after create product group", STATUS_CODE_INVALID_CONTENT,
1547                                         createGroupingRest.getErrorCode().intValue());
1548                         productGroupingDefinition.setNormalizedName("");
1549                         getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails, PRODUCT_COMPONENT_TYPE);
1550                         assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1551                                         getAllCategoriesRest.getErrorCode().intValue());
1552                         CategoryValidationUtils.verifyGroupingNotExistInGetResponse(getAllCategoriesRest,
1553                                         productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1554                                         productGroupingDefinition);
1555                         // Audit validation
1556                         AuditValidationUtils.groupingAuditFailure(ADD_GROUPING, productCategoryDefinition,
1557                                         productSubCategoryDefinition, productGroupingDefinition, sdncProductStrategistUserDetails,
1558                                         ActionStatus.COMPONENT_ELEMENT_INVALID_NAME_FORMAT, STATUS_CODE_INVALID_CONTENT, AUDIT_PRODUCT_TYPE,
1559                                         AUDIT_PRODUCT_TYPE, GROUPING);
1560                 }
1561         }
1562
1563         @Test
1564         public void groupNameValidationConjunctions_01() throws Exception {
1565                 // Normalize the grouping name conjunctions ('of', 'to', 'for', 'as',
1566                 // 'a', 'an' , 'the') are lower case.
1567                 productGroupingDefinition.setName(" bank OF america  ");
1568                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1569                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1570                                 PRODUCT_COMPONENT_TYPE);
1571                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1572                                 createGroupingRest.getErrorCode().intValue());
1573                 productGroupingDefinition.setNormalizedName("bank of america");
1574                 productGroupingDefinition.setName("Bank of America");
1575                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1576                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1577                                 PRODUCT_COMPONENT_TYPE);
1578                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1579                                 getAllCategoriesRest.getErrorCode().intValue());
1580                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1581                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1582                                 productGroupingDefinition);
1583                 // Audit validation
1584                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1585                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1586         }
1587
1588         @Test
1589         public void groupNameValidationConjunctions_02() throws Exception {
1590                 // Normalize the grouping name conjunctions ('of', 'to', 'for', 'as',
1591                 // 'a', 'an' , 'the') are lower case.
1592                 productGroupingDefinition.setName("THE america bank   ");
1593                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1594                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1595                                 PRODUCT_COMPONENT_TYPE);
1596                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1597                                 createGroupingRest.getErrorCode().intValue());
1598                 productGroupingDefinition.setName("THE America Bank");
1599                 productGroupingDefinition.setNormalizedName("the america bank");
1600                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1601                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1602                                 PRODUCT_COMPONENT_TYPE);
1603                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1604                                 getAllCategoriesRest.getErrorCode().intValue());
1605                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1606                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1607                                 productGroupingDefinition);
1608                 // Audit validation
1609                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1610                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1611         }
1612
1613         @Test
1614         public void groupNameValidationConjunctions_03() throws Exception {
1615                 // Normalize the grouping name conjunctions ('of', 'to', 'for', 'as',
1616                 // 'a', 'an' , 'the') are lower case.
1617                 productGroupingDefinition.setName("   A bank OF america  ");
1618                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1619                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1620                                 PRODUCT_COMPONENT_TYPE);
1621                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1622                                 createGroupingRest.getErrorCode().intValue());
1623                 productGroupingDefinition.setName("A Bank of America");
1624                 productGroupingDefinition.setNormalizedName("a bank of america");
1625                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1626                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1627                                 PRODUCT_COMPONENT_TYPE);
1628                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1629                                 getAllCategoriesRest.getErrorCode().intValue());
1630                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1631                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1632                                 productGroupingDefinition);
1633                 // Audit validation
1634                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1635                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1636         }
1637
1638         @Test
1639         public void groupNameValidationConjunctions_04() throws Exception {
1640                 // Normalize the grouping name conjunctions ('of', 'to', 'for', 'as',
1641                 // 'a', 'an' , 'the') are lower case.
1642                 productGroupingDefinition.setName("  bank  america is A big ban  ");
1643                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1644                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1645                                 PRODUCT_COMPONENT_TYPE);
1646                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1647                                 createGroupingRest.getErrorCode().intValue());
1648                 productGroupingDefinition.setName("Bank America Is a Big Ban");
1649                 productGroupingDefinition.setNormalizedName("bank america is a big ban");
1650                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1651                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1652                                 PRODUCT_COMPONENT_TYPE);
1653                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1654                                 getAllCategoriesRest.getErrorCode().intValue());
1655                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1656                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1657                                 productGroupingDefinition);
1658                 // Audit validation
1659                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1660                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1661         }
1662
1663         @Test
1664         public void groupNameValidationConjunctions_05() throws Exception {
1665                 // Normalize the grouping name conjunctions ('of', 'to', 'for', 'as',
1666                 // 'a', 'an' , 'the') are lower case.
1667                 productGroupingDefinition.setName(" aN apple comPany inC ");
1668                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1669                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1670                                 PRODUCT_COMPONENT_TYPE);
1671                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1672                                 createGroupingRest.getErrorCode().intValue());
1673                 productGroupingDefinition.setName("AN Apple ComPany InC");
1674                 productGroupingDefinition.setNormalizedName("an apple company inc");
1675                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1676                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1677                                 PRODUCT_COMPONENT_TYPE);
1678                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1679                                 getAllCategoriesRest.getErrorCode().intValue());
1680                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1681                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1682                                 productGroupingDefinition);
1683                 // Audit validation
1684                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1685                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1686         }
1687
1688         @Test
1689         public void groupNameValidationConjunctions_06() throws Exception {
1690                 // Normalize the grouping name conjunctions ('of', 'to', 'for', 'as',
1691                 // 'a', 'an' , 'the') are lower case.
1692                 productGroupingDefinition.setName(" eat AN apple ANAN");
1693                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1694                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1695                                 PRODUCT_COMPONENT_TYPE);
1696                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1697                                 createGroupingRest.getErrorCode().intValue());
1698                 productGroupingDefinition.setName("Eat an Apple ANAN");
1699                 productGroupingDefinition.setNormalizedName("eat an apple anan");
1700                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1701                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1702                                 PRODUCT_COMPONENT_TYPE);
1703                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1704                                 getAllCategoriesRest.getErrorCode().intValue());
1705                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1706                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1707                                 productGroupingDefinition);
1708                 // Audit validation
1709                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1710                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1711         }
1712
1713         @Test
1714         public void groupNameValidationConjunctions_07() throws Exception {
1715                 // Normalize the grouping name conjunctions ('of', 'to', 'for', 'as',
1716                 // 'a', 'an' , 'the') are lower case.
1717                 productGroupingDefinition.setName(" united states OF americA ");
1718                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1719                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1720                                 PRODUCT_COMPONENT_TYPE);
1721                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1722                                 createGroupingRest.getErrorCode().intValue());
1723                 productGroupingDefinition.setName("United States of AmericA");
1724                 productGroupingDefinition.setNormalizedName("united states of america");
1725                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1726                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1727                                 PRODUCT_COMPONENT_TYPE);
1728                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1729                                 getAllCategoriesRest.getErrorCode().intValue());
1730                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1731                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1732                                 productGroupingDefinition);
1733                 // Audit validation
1734                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1735                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1736         }
1737
1738         @Test
1739         public void groupNameValidationConjunctions_08() throws Exception {
1740                 // Normalize the grouping name conjunctions ('of', 'to', 'for', 'as',
1741                 // 'a', 'an' , 'the') are lower case.
1742                 productGroupingDefinition.setName(" oF united states OF amer ");
1743                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1744                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1745                                 PRODUCT_COMPONENT_TYPE);
1746                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1747                                 createGroupingRest.getErrorCode().intValue());
1748                 productGroupingDefinition.setName("OF United States of Amer");
1749                 productGroupingDefinition.setNormalizedName("of united states of amer");
1750                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1751                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1752                                 PRODUCT_COMPONENT_TYPE);
1753                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1754                                 getAllCategoriesRest.getErrorCode().intValue());
1755                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1756                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1757                                 productGroupingDefinition);
1758                 // Audit validation
1759                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1760                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1761         }
1762
1763         @Test
1764         public void groupNameValidationConjunctions_09() throws Exception {
1765                 // Normalize the grouping name conjunctions ('of', 'to', 'for', 'as',
1766                 // 'a', 'an' , 'the') are lower case.
1767                 productGroupingDefinition.setName(" to Apple TO at&T TOO ");
1768                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1769                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1770                                 PRODUCT_COMPONENT_TYPE);
1771                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1772                                 createGroupingRest.getErrorCode().intValue());
1773                 productGroupingDefinition.setName("To Apple to At&T TOO");
1774                 productGroupingDefinition.setNormalizedName("to apple to at&t too");
1775                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1776                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1777                                 PRODUCT_COMPONENT_TYPE);
1778                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1779                                 getAllCategoriesRest.getErrorCode().intValue());
1780                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1781                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1782                                 productGroupingDefinition);
1783                 // Audit validation
1784                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1785                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1786         }
1787
1788         @Test
1789         public void groupNameValidationConjunctions_10() throws Exception {
1790                 // Normalize the grouping name conjunctions ('of', 'to', 'for', 'as',
1791                 // 'a', 'an' , 'the') are lower case.
1792                 productGroupingDefinition.setName(" eat apple AS you liiikeas ");
1793                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1794                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1795                                 PRODUCT_COMPONENT_TYPE);
1796                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1797                                 createGroupingRest.getErrorCode().intValue());
1798                 productGroupingDefinition.setName("Eat Apple as You Liiikeas");
1799                 productGroupingDefinition.setNormalizedName("eat apple as you liiikeas");
1800                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1801                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1802                                 PRODUCT_COMPONENT_TYPE);
1803                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1804                                 getAllCategoriesRest.getErrorCode().intValue());
1805                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1806                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1807                                 productGroupingDefinition);
1808                 // Audit validation
1809                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1810                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1811         }
1812
1813         @Test
1814         public void groupNameValidationConjunctions_11() throws Exception {
1815                 // Normalize the grouping name conjunctions ('of', 'to', 'for', 'as',
1816                 // 'a', 'an' , 'the') are lower case.
1817                 productGroupingDefinition.setName(" as you may want ");
1818                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1819                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1820                                 PRODUCT_COMPONENT_TYPE);
1821                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1822                                 createGroupingRest.getErrorCode().intValue());
1823                 productGroupingDefinition.setName("As You May Want");
1824                 productGroupingDefinition.setNormalizedName("as you may want");
1825                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1826                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1827                                 PRODUCT_COMPONENT_TYPE);
1828                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1829                                 getAllCategoriesRest.getErrorCode().intValue());
1830                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1831                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1832                                 productGroupingDefinition);
1833                 // Audit validation
1834                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1835                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1836         }
1837
1838         @Test
1839         public void groupNameValidationConjunctions_12() throws Exception {
1840                 // Normalize the grouping name conjunctions ('of', 'to', 'for', 'as',
1841                 // 'a', 'an' , 'the') are lower case.
1842                 productGroupingDefinition.setName(" the bank OF america ");
1843                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1844                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1845                                 PRODUCT_COMPONENT_TYPE);
1846                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1847                                 createGroupingRest.getErrorCode().intValue());
1848                 productGroupingDefinition.setName("The Bank of America");
1849                 productGroupingDefinition.setNormalizedName("the bank of america");
1850                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1851                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1852                                 PRODUCT_COMPONENT_TYPE);
1853                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1854                                 getAllCategoriesRest.getErrorCode().intValue());
1855                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1856                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1857                                 productGroupingDefinition);
1858                 // Audit validation
1859                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1860                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1861         }
1862
1863         @Test
1864         public void groupNameValidationConjunctions_13() throws Exception {
1865                 // Normalize the grouping name conjunctions ('of', 'to', 'for', 'as',
1866                 // 'a', 'an' , 'the') are lower case.
1867                 productGroupingDefinition.setName("  To tel-toto ");
1868                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1869                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1870                                 PRODUCT_COMPONENT_TYPE);
1871                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1872                                 createGroupingRest.getErrorCode().intValue());
1873                 productGroupingDefinition.setName("To Tel-toto");
1874                 productGroupingDefinition.setNormalizedName("to tel-toto");
1875                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1876                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1877                                 PRODUCT_COMPONENT_TYPE);
1878                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1879                                 getAllCategoriesRest.getErrorCode().intValue());
1880                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1881                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1882                                 productGroupingDefinition);
1883                 // Audit validation
1884                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1885                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1886         }
1887
1888         @Test
1889         public void groupNameValidationConjunctions_14() throws Exception {
1890                 // Normalize the grouping name conjunctions ('of', 'to', 'for', 'as',
1891                 // 'a', 'an' , 'the') are lower case.
1892                 productGroupingDefinition.setName("   tel-aviv To   la ");
1893                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1894                                 productSubCategoryDefinition, productCategoryDefinition, sdncProductStrategistUserDetails,
1895                                 PRODUCT_COMPONENT_TYPE);
1896                 assertEquals("Check response code after create product group", STATUS_CODE_CREATED,
1897                                 createGroupingRest.getErrorCode().intValue());
1898                 productGroupingDefinition.setName("Tel-aviv to La");
1899                 productGroupingDefinition.setNormalizedName("tel-aviv to la");
1900                 CategoryValidationUtils.validateCreateGroupResponse(createGroupingRest, productGroupingDefinition);
1901                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1902                                 PRODUCT_COMPONENT_TYPE);
1903                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1904                                 getAllCategoriesRest.getErrorCode().intValue());
1905                 CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
1906                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1907                                 productGroupingDefinition);
1908                 // Audit validation
1909                 AuditValidationUtils.groupingAuditSuccess(ADD_GROUPING, productCategoryDefinition, productSubCategoryDefinition,
1910                                 productGroupingDefinition, sdncProductStrategistUserDetails, STATUS_CODE_CREATED, AUDIT_PRODUCT_TYPE);
1911         }
1912
1913         @Test
1914         public void createProductGroupHttpCspUserIdIsEmpty() throws Exception {
1915                 User sdncPS = ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_STRATEGIST1);
1916                 sdncPS.setUserId("");
1917                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1918                                 productSubCategoryDefinition, productCategoryDefinition, sdncPS, PRODUCT_COMPONENT_TYPE);
1919                 assertEquals("Check response code after create Consumer", STATUS_CODE_MISSING_INFORMATION,
1920                                 createGroupingRest.getErrorCode().intValue());
1921                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1922                                 PRODUCT_COMPONENT_TYPE);
1923                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1924                                 getAllCategoriesRest.getErrorCode().intValue());
1925                 CategoryValidationUtils.verifyGroupingNotExistInGetResponse(getAllCategoriesRest,
1926                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1927                                 productGroupingDefinition);
1928                 // Audit validation
1929                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_INFORMATION.name());
1930                 ExpectedCategoryAudit expectedCatrgoryAuditJavaObject = new ExpectedCategoryAudit();
1931                 expectedCatrgoryAuditJavaObject.setAction(ADD_GROUPING);
1932                 expectedCatrgoryAuditJavaObject.setModifier("");
1933                 expectedCatrgoryAuditJavaObject.setCategoryName(productCategoryDefinition.getUniqueId());
1934                 expectedCatrgoryAuditJavaObject.setSubCategoryName(productSubCategoryDefinition.getUniqueId());
1935                 expectedCatrgoryAuditJavaObject.setGroupingName(productGroupingDefinition.getName());
1936                 expectedCatrgoryAuditJavaObject.setResourceType(AUDIT_PRODUCT_TYPE);
1937                 expectedCatrgoryAuditJavaObject.setStatus(String.valueOf(STATUS_CODE_MISSING_INFORMATION));
1938                 expectedCatrgoryAuditJavaObject.setDesc(errorInfo.getAuditDesc());
1939                 AuditValidationUtils.validateCategoryAudit(expectedCatrgoryAuditJavaObject, ADD_GROUPING);
1940         }
1941
1942         @Test
1943         public void createProductGroupHttpCspUserIdIsNull() throws Exception {
1944                 User sdncPS = ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_STRATEGIST1);
1945                 sdncPS.setUserId(null);
1946                 RestResponse createGroupingRest = CategoryRestUtils.createGrouping(productGroupingDefinition,
1947                                 productSubCategoryDefinition, productCategoryDefinition, sdncPS, PRODUCT_COMPONENT_TYPE);
1948                 assertEquals("Check response code after create Consumer", STATUS_CODE_MISSING_INFORMATION,
1949                                 createGroupingRest.getErrorCode().intValue());
1950                 RestResponse getAllCategoriesRest = CategoryRestUtils.getAllCategories(sdncAdminUserDetails,
1951                                 PRODUCT_COMPONENT_TYPE);
1952                 assertEquals("Check response code after get all categories ", STATUS_CODE_SUCCESS,
1953                                 getAllCategoriesRest.getErrorCode().intValue());
1954                 CategoryValidationUtils.verifyGroupingNotExistInGetResponse(getAllCategoriesRest,
1955                                 productCategoryDefinition.getUniqueId(), productSubCategoryDefinition.getUniqueId(),
1956                                 productGroupingDefinition);
1957                 // Audit validation
1958                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_INFORMATION.name());
1959                 ExpectedCategoryAudit expectedCatrgoryAuditJavaObject = new ExpectedCategoryAudit();
1960                 expectedCatrgoryAuditJavaObject.setAction(ADD_GROUPING);
1961                 expectedCatrgoryAuditJavaObject.setModifier("");
1962                 expectedCatrgoryAuditJavaObject.setCategoryName(productCategoryDefinition.getUniqueId());
1963                 expectedCatrgoryAuditJavaObject.setSubCategoryName(productSubCategoryDefinition.getUniqueId());
1964                 expectedCatrgoryAuditJavaObject.setGroupingName(productGroupingDefinition.getName());
1965                 expectedCatrgoryAuditJavaObject.setResourceType(AUDIT_PRODUCT_TYPE);
1966                 expectedCatrgoryAuditJavaObject.setStatus(String.valueOf(STATUS_CODE_MISSING_INFORMATION));
1967                 expectedCatrgoryAuditJavaObject.setDesc(errorInfo.getAuditDesc());
1968                 AuditValidationUtils.validateCategoryAudit(expectedCatrgoryAuditJavaObject, ADD_GROUPING);
1969         }
1970
1971         ////////////////////////////////////////////////
1972         ///////////////////////////////////////////////
1973         @Test
1974         public void getProductCategoryHierarchySuccessFlow() throws Exception {
1975                 throw new SkipException(
1976                                 "Skipping - failed in audit validation expected \"products\" actual result was \"product\" ");
1977                 // int numOfGrouping = 3;
1978                 // List<GroupingDefinition> groupingList = new ArrayList<>();
1979                 // RestResponse restResponse;
1980                 // GroupingDefinition grouping;
1981                 // String groupingName = productGroupingDefinition.getName();
1982                 // for (int i = 0; i < numOfGrouping; i++) {
1983                 // productGroupingDefinition.setName(groupingName+i);
1984                 // restResponse =
1985                 // CategoryRestUtils.createGrouping(productGroupingDefinition,
1986                 // productSubCategoryDefinition, productCategoryDefinition,
1987                 // sdncProductStrategistUserDetails, PRODUCT_COMPONENT_TYPE);
1988                 // grouping = ResponseParser.parseToObject(restResponse.getResponse(),
1989                 // GroupingDefinition.class);
1990                 // groupingList.add(grouping);
1991                 // }
1992                 // RestResponse getAllCategoriesRest =
1993                 // CategoryRestUtils.getAllCategories(sdncProductStrategistUserDetails,
1994                 // PRODUCT_COMPONENT_TYPE);
1995                 // assertEquals("Check response code after get all categories ",
1996                 // STATUS_CODE_SUCCESS, getAllCategoriesRest.getErrorCode().intValue());
1997                 // AuditValidationUtils.GetCategoryHierarchyAuditSuccess(GET_CATEGORY_HIERARCHY,
1998                 // AUDIT_PRODUCT_TYPE, sdncProductStrategistUserDetails,
1999                 // STATUS_CODE_SUCCESS);
2000                 //
2001                 // for (GroupingDefinition group : groupingList) {
2002                 // CategoryValidationUtils.verifyGroupingExistInGetResponse(getAllCategoriesRest,
2003                 // productCategoryDefinition.getUniqueId(),
2004                 // productSubCategoryDefinition.getUniqueId(), group);
2005                 // }
2006         }
2007 }