gerrit.onap Code Review - sdc.git/blob

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