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