asdc-tests/src/main/java/org/openecomp/sdc/ci/tests/execute/general/ManageEcompConsumerCredentials.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.ci.tests.execute.general;
  22
  23 import static org.testng.AssertJUnit.assertEquals;
  24
  25 import java.util.HashMap;
  26
  27 import org.junit.Rule;
  28 import org.junit.rules.TestName;
  29 import org.openecomp.sdc.be.dao.api.ActionStatus;
  30 import org.openecomp.sdc.be.datatypes.elements.ConsumerDataDefinition;
  31 import org.openecomp.sdc.be.model.User;
  32 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  33 import org.openecomp.sdc.ci.tests.datatypes.enums.ErrorInfo;
  34 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  35 import org.openecomp.sdc.ci.tests.datatypes.expected.ExpectedEcomConsumerAudit;
  36 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  37 import org.openecomp.sdc.ci.tests.utils.DbUtils;
  38 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  39 import org.openecomp.sdc.ci.tests.utils.rest.ConsumerRestUtils;
  40 import org.openecomp.sdc.ci.tests.utils.validation.AuditValidationUtils;
  41 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  42 import org.testng.AssertJUnit;
  43 import org.testng.annotations.BeforeMethod;
  44 import org.testng.annotations.Test;
  45
  46 import com.google.gson.Gson;
  47
  48 public class ManageEcompConsumerCredentials extends ComponentBaseTest {
  49
  50         protected static final String ADD_ECOMP_USER_CREDENTIALS = "AddECOMPUserCredentials";
  51         protected static final String DELETE_ECOMP_USER_CREDENTIALS = "DeleteECOMPUserCredentials";
  52         protected static final String GET_ECOMP_USER_CREDENTIALS = "GetECOMPUserCredentials";
  53
  54         public static final String contentTypeHeaderData = "application/json";
  55         public static final String acceptHeaderData = "application/json";
  56
  57         public static final int STATUS_CODE_SUCCESS = 200;
  58         public static final int STATUS_CODE_SUCSESS_CREATED = 201;
  59         public static final int STATUS_CODE_SUCCESS_DELETE_GET = 200;
  60         public static final int STATUS_CODE_INVALID_CONTENT = 400;
  61         public static final int STATUS_CODE_MISSING_DATA = 400;
  62         public static final int STATUS_CODE_MISSING_INFORMATION = 403;
  63         public static final int STATUS_CODE_RESTRICTED_ACCESS = 403;
  64
  65         public static final int STATUS_CODE_NOT_FOUND = 404;
  66         public static final int STATUS_CODE_RESTRICTED_OPERATION = 409;
  67
  68         protected static Gson gson = new Gson();
  69         protected ConsumerDataDefinition consumerDataDefinition;
  70         protected User sdncAdminUserDetails;
  71         protected User sdncDesignerUserDetails;
  72         protected User sdncTesterUserDetails;
  73         protected User sdncGovernorUserDetails;
  74         protected User sdncOpsUserDetails;
  75
  76         public ManageEcompConsumerCredentials() {
  77                 super(name, ManageEcompConsumerCredentials.class.getName());
  78         }
  79
  80         @Rule
  81         public static TestName name = new TestName();
  82
  83         protected String salt = "123456789012345678901234567890ab";
  84         protected String password = "123456789012345678901234567890ab123456789012345678901234567890ab";
  85         protected String ecompUser = "benny";
  86
  87         protected Long consumerDetailsLastupdatedtime;
  88
  89         @BeforeMethod
  90         public void init() throws Exception {
  91                 sdncAdminUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
  92                 sdncDesignerUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
  93                 sdncTesterUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
  94                 sdncGovernorUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR);
  95                 sdncOpsUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.OPS);
  96
  97                 consumerDataDefinition = new ConsumerDataDefinition();
  98                 consumerDataDefinition.setConsumerName(ecompUser);
  99                 consumerDataDefinition.setConsumerPassword(password);
 100                 consumerDataDefinition.setConsumerSalt(salt);
 101                 ConsumerRestUtils.deleteConsumer(consumerDataDefinition, sdncAdminUserDetails);
 102
 103         }
 104
 105         // US563681 manage ECOMP consumer credentials - DELETE/GET
 106         @Test
 107         public void deleteEcompCredentialsMethodDelete() throws Exception {
 108                 // Create Consumer
 109                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 110                                 sdncAdminUserDetails);
 111                 AssertJUnit.assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
 112                                 createConsumerRest.getErrorCode().intValue());
 113                 // Get Consumer
 114                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 115                 AssertJUnit.assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
 116                                 getConsumerRest.getErrorCode().intValue());
 117                 // Delete consumer
 118                 // DbUtils.deleteFromEsDbByPattern("_all");
 119                 DbUtils.cleanAllAudits();
 120                 RestResponse deleteConsumerRest = ConsumerRestUtils.deleteConsumer(consumerDataDefinition,
 121                                 sdncAdminUserDetails);
 122                 AssertJUnit.assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS_DELETE_GET,
 123                                 deleteConsumerRest.getErrorCode().intValue());
 124                 // Audit validation
 125                 AuditValidationUtils.ecompConsumerAuditSuccess(DELETE_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
 126                                 sdncAdminUserDetails, STATUS_CODE_SUCCESS_DELETE_GET);
 127                 // Get Consumer to verify that consumer user does not exist
 128                 getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 129                 AssertJUnit.assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
 130                                 getConsumerRest.getErrorCode().intValue());
 131         }
 132
 133         //// US561728 CREATE ECOMP consumer credentials
 134         @Test
 135         public void createEcompCredentialsMethodPost() throws Exception {
 136                 // Create Consumer
 137                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 138                                 sdncAdminUserDetails);
 139                 assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
 140                                 createConsumerRest.getErrorCode().intValue());
 141                 // parse updated response to javaObject
 142                 ConsumerDataDefinition getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(createConsumerRest);
 143                 // Validate actual consumerData to returned from response
 144                 ConsumerRestUtils.validateConsumerReqVsResp(consumerDataDefinition, getConsumerDataObject);
 145
 146                 // Get Consumer
 147                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 148                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
 149                                 getConsumerRest.getErrorCode().intValue());
 150                 getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(getConsumerRest);
 151                 ConsumerRestUtils.validateConsumerReqVsResp(consumerDataDefinition, getConsumerDataObject);
 152                 // Audit validation
 153                 AuditValidationUtils.ecompConsumerAuditSuccess(ADD_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
 154                                 sdncAdminUserDetails, STATUS_CODE_SUCSESS_CREATED);
 155         }
 156
 157         @Test(enabled = false)
 158         public void createEcompCredentialsUserAlreayExist() throws Exception {
 159                 // Create Consumer
 160                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 161                                 sdncAdminUserDetails);
 162                 assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
 163                                 createConsumerRest.getErrorCode().intValue());
 164                 ConsumerDataDefinition getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(createConsumerRest);
 165                 ConsumerRestUtils.validateConsumerReqVsResp(consumerDataDefinition, getConsumerDataObject);
 166                 // Get Consumer
 167                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 168                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
 169                                 getConsumerRest.getErrorCode().intValue());
 170                 getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(getConsumerRest);
 171                 ConsumerRestUtils.validateConsumerReqVsResp(consumerDataDefinition, getConsumerDataObject);
 172
 173                 // Create consumer which already exists with different password and Salt
 174                 DbUtils.deleteFromEsDbByPattern("_all");
 175                 consumerDataDefinition.setConsumerPassword("zxcvb");
 176                 consumerDataDefinition.setConsumerSalt("1234567890qwertyuiop1234567890as");
 177                 createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition, sdncAdminUserDetails);
 178                 assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
 179                                 createConsumerRest.getErrorCode().intValue());
 180                 // Get Consumer with new data
 181                 getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 182                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
 183                                 getConsumerRest.getErrorCode().intValue());
 184                 getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(getConsumerRest);
 185                 ConsumerRestUtils.validateConsumerReqVsResp(consumerDataDefinition, getConsumerDataObject);
 186                 // Audit validation
 187                 AuditValidationUtils.ecompConsumerAuditSuccess(ADD_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
 188                                 sdncAdminUserDetails, STATUS_CODE_SUCSESS_CREATED);
 189                 // Delete Consumer
 190                 ConsumerRestUtils.deleteConsumer(consumerDataDefinition, sdncAdminUserDetails);
 191         }
 192
 193         @Test
 194         public void createEcompCredentialsByDesigner() throws Exception { // HttpCspUserId
 195                                                                                                                                                 // header
 196                                                                                                                                                 // contains
 197                                                                                                                                                 // Designer
 198                                                                                                                                                 // UserId
 199                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 200                                 sdncDesignerUserDetails);
 201                 assertEquals("Check response code after create Consumer", STATUS_CODE_RESTRICTED_OPERATION,
 202                                 createConsumerRest.getErrorCode().intValue());
 203                 // Get Consumer
 204                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 205                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
 206                                 getConsumerRest.getErrorCode().intValue());
 207                 // Audit validation
 208                 AuditValidationUtils.createEcompConsumerAuditFailure(ADD_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
 209                                 sdncDesignerUserDetails, ActionStatus.RESTRICTED_OPERATION);
 210         }
 211
 212         @Test
 213         public void createEcompCredentialsByTester() throws Exception { // HttpCspUserId
 214                                                                                                                                         // header
 215                                                                                                                                         // contains
 216                                                                                                                                         // Tester
 217                                                                                                                                         // UserId
 218                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 219                                 sdncTesterUserDetails);
 220                 assertEquals("Check response code after create Consumer", STATUS_CODE_RESTRICTED_OPERATION,
 221                                 createConsumerRest.getErrorCode().intValue());
 222                 // Get Consumer
 223                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 224                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
 225                                 getConsumerRest.getErrorCode().intValue());
 226                 // Audit validation
 227                 AuditValidationUtils.createEcompConsumerAuditFailure(ADD_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
 228                                 sdncTesterUserDetails, ActionStatus.RESTRICTED_OPERATION);
 229         }
 230
 231         @Test
 232         public void createEcompCredentialsByOps() throws Exception { // HttpCspUserId
 233                                                                                                                                         // header
 234                                                                                                                                         // contains
 235                                                                                                                                         // OPS
 236                                                                                                                                         // UserId
 237                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition, sdncOpsUserDetails);
 238                 assertEquals("Check response code after create Consumer", STATUS_CODE_RESTRICTED_OPERATION,
 239                                 createConsumerRest.getErrorCode().intValue());
 240                 // Get Consumer
 241                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 242                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
 243                                 getConsumerRest.getErrorCode().intValue());
 244                 // Audit validation
 245                 AuditValidationUtils.createEcompConsumerAuditFailure(ADD_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
 246                                 sdncOpsUserDetails, ActionStatus.RESTRICTED_OPERATION);
 247         }
 248
 249         @Test
 250         public void createEcompCredentialsByGovernor() throws Exception { // HttpCspUserId
 251                                                                                                                                                 // header
 252                                                                                                                                                 // contains
 253                                                                                                                                                 // Governor
 254                                                                                                                                                 // UserId
 255                                                                                                                                                 // Create
 256                                                                                                                                                 // Consumer
 257                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 258                                 sdncGovernorUserDetails);
 259                 assertEquals("Check response code after create Consumer", STATUS_CODE_RESTRICTED_OPERATION,
 260                                 createConsumerRest.getErrorCode().intValue());
 261                 // Get Consumer
 262                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 263                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
 264                                 getConsumerRest.getErrorCode().intValue());
 265                 // Audit validation
 266                 AuditValidationUtils.createEcompConsumerAuditFailure(ADD_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
 267                                 sdncGovernorUserDetails, ActionStatus.RESTRICTED_OPERATION);
 268         }
 269
 270         @Test
 271         public void createEcompCredentialsByNoExistingIUser() throws Exception {
 272                 User noSdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 273                 noSdncUserDetails.setRole("blabla");
 274                 noSdncUserDetails.setUserId("bt750h");
 275                 DbUtils.deleteFromEsDbByPattern("_all");
 276                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition, noSdncUserDetails);
 277                 assertEquals("Check response code after create Consumer", STATUS_CODE_RESTRICTED_OPERATION,
 278                                 createConsumerRest.getErrorCode().intValue());
 279                 // verify that consumer didn't created
 280                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 281                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
 282                                 getConsumerRest.getErrorCode().intValue());
 283                 // Audit validation
 284                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_ACCESS.name());
 285                 ExpectedEcomConsumerAudit expectedEcomConsumerAuditJavaObject = new ExpectedEcomConsumerAudit();
 286                 expectedEcomConsumerAuditJavaObject.setAction(ADD_ECOMP_USER_CREDENTIALS);
 287                 expectedEcomConsumerAuditJavaObject.setEcomUser(
 288                                 consumerDataDefinition.getConsumerName() + "," + consumerDataDefinition.getConsumerSalt().toLowerCase()
 289                                                 + "," + consumerDataDefinition.getConsumerPassword());
 290                 expectedEcomConsumerAuditJavaObject.setStatus(errorInfo.getCode().toString());
 291                 expectedEcomConsumerAuditJavaObject.setDesc(errorInfo.getAuditDesc(""));
 292                 expectedEcomConsumerAuditJavaObject.setModifier("(" + noSdncUserDetails.getUserId() + ")");
 293                 AuditValidationUtils.validateEcompConsumerAudit(expectedEcomConsumerAuditJavaObject,
 294                                 ADD_ECOMP_USER_CREDENTIALS);
 295         }
 296
 297         // user name
 298         @Test
 299         public void createEcompCredentialsUserNameIsNull() throws Exception {
 300                 consumerDataDefinition.setConsumerName(null); // SVC4528
 301                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 302                                 sdncAdminUserDetails);
 303                 assertEquals("Check response code after create Consumer", STATUS_CODE_MISSING_DATA,
 304                                 createConsumerRest.getErrorCode().intValue());
 305                 // verify taht consumer didn't created
 306                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 307                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
 308                                 getConsumerRest.getErrorCode().intValue());
 309                 // validate audit
 310                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_DATA.name());
 311                 ExpectedEcomConsumerAudit expectedEcomConsumerAuditJavaObject = new ExpectedEcomConsumerAudit();
 312                 expectedEcomConsumerAuditJavaObject.setAction(ADD_ECOMP_USER_CREDENTIALS);
 313                 expectedEcomConsumerAuditJavaObject.setEcomUser(consumerDataDefinition.getConsumerSalt().toLowerCase() + ","
 314                                 + consumerDataDefinition.getConsumerPassword());
 315                 expectedEcomConsumerAuditJavaObject.setStatus(errorInfo.getCode().toString());
 316                 expectedEcomConsumerAuditJavaObject.setDesc(errorInfo.getAuditDesc("Consumer name"));
 317                 expectedEcomConsumerAuditJavaObject
 318                                 .setModifier(sdncAdminUserDetails.getFullName() + "(" + sdncAdminUserDetails.getUserId() + ")");
 319                 AuditValidationUtils.validateEcompConsumerAudit(expectedEcomConsumerAuditJavaObject,
 320                                 ADD_ECOMP_USER_CREDENTIALS);
 321         }
 322
 323         @Test
 324         public void createEcompCredentialsUserNameIsEmpty() throws Exception {
 325                 consumerDataDefinition.setConsumerName("");
 326                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 327                                 sdncAdminUserDetails);
 328                 assertEquals("Check response code after create Consumer", STATUS_CODE_INVALID_CONTENT,
 329                                 createConsumerRest.getErrorCode().intValue());
 330                 // validate audit
 331                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_DATA.name());
 332                 ExpectedEcomConsumerAudit expectedEcomConsumerAuditJavaObject = new ExpectedEcomConsumerAudit();
 333                 expectedEcomConsumerAuditJavaObject.setAction(ADD_ECOMP_USER_CREDENTIALS);
 334                 expectedEcomConsumerAuditJavaObject.setEcomUser(consumerDataDefinition.getConsumerSalt().toLowerCase() + ","
 335                                 + consumerDataDefinition.getConsumerPassword());
 336                 expectedEcomConsumerAuditJavaObject.setStatus(errorInfo.getCode().toString());
 337                 expectedEcomConsumerAuditJavaObject.setDesc(errorInfo.getAuditDesc("Consumer name"));
 338                 expectedEcomConsumerAuditJavaObject
 339                                 .setModifier(sdncAdminUserDetails.getFullName() + "(" + sdncAdminUserDetails.getUserId() + ")");
 340                 AuditValidationUtils.validateEcompConsumerAudit(expectedEcomConsumerAuditJavaObject,
 341                                 ADD_ECOMP_USER_CREDENTIALS);
 342         }
 343
 344         @Test
 345         public void createEcompCredentialsUserNameIsNotUTF8() throws Exception {
 346                 consumerDataDefinition.setConsumerName("בני"); // SVC4528
 347                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 348                                 sdncAdminUserDetails);
 349                 assertEquals("Check response code after create Consumer", STATUS_CODE_INVALID_CONTENT,
 350                                 createConsumerRest.getErrorCode().intValue());
 351                 // verify that consumer didn't created
 352                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 353                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
 354                                 getConsumerRest.getErrorCode().intValue());
 355         }
 356
 357         @Test
 358         public void createEcompCredentialsUserNameMaxLength() throws Exception {
 359                 consumerDataDefinition.setConsumerName(
 360                                 "_ABCD-.abcdqwertyuiopasdfghjklzxcvbnmqw1234567890poiutrewasdfghjklqwertyuiopzaiutrewasdfg34567890poiutrewasdfghjklqwertyuiopzaiutrewasdfg34567890pf34567890poiutrewasdfghjklqwertyuiopzaiutrewasdfgghjklqwertyuiopzaiutrewasdfghjklqwertyuiopzasxcdferf123456.-"); // SVC4528
 361                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 362                                 sdncAdminUserDetails);
 363                 assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
 364                                 createConsumerRest.getErrorCode().intValue());
 365                 // Validate actual consumerData to returned from response
 366                 ConsumerDataDefinition getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(createConsumerRest);
 367                 ConsumerRestUtils.validateConsumerReqVsResp(consumerDataDefinition, getConsumerDataObject);
 368                 // Get Consumer
 369                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 370                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
 371                                 getConsumerRest.getErrorCode().intValue());
 372                 getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(getConsumerRest);
 373                 ConsumerRestUtils.validateConsumerReqVsResp(consumerDataDefinition, getConsumerDataObject);
 374                 // Audit validation
 375                 AuditValidationUtils.ecompConsumerAuditSuccess(ADD_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
 376                                 sdncAdminUserDetails, STATUS_CODE_SUCSESS_CREATED);
 377                 // Delete Consumer
 378                 ConsumerRestUtils.deleteConsumer(consumerDataDefinition, sdncAdminUserDetails);
 379         }
 380
 381         @Test
 382         public void createEcompCredentialsUserNameExceedMaxLength() throws Exception {
 383                 consumerDataDefinition.setConsumerName(
 384                                 "_ABCD-.abcdqwertyuiopasdfghjklzxcvbnmqw1234567890poiutrewasdfghjklqwertyuiopzaiutrewasdfg34567890poiutrewasdfghjklqwertyuiopzaiutrewasdfg34567890pf34567890poiutrewasdfghjklqwertyuiopzaiutrewasdfgghjklqwertyuiopzaiutrewasdfghjklqwertyuiopzasxcdferf123456.--"); // SVC4528
 385                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 386                                 sdncAdminUserDetails);
 387                 assertEquals("Check response code after create Consumer", STATUS_CODE_INVALID_CONTENT,
 388                                 createConsumerRest.getErrorCode().intValue());
 389                 // verify that consumer didn't created
 390                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 391                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
 392                                 getConsumerRest.getErrorCode().intValue());
 393                 // Audit validation
 394                 AuditValidationUtils.createEcompConsumerAuditFailure(ADD_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
 395                                 sdncAdminUserDetails, ActionStatus.EXCEEDS_LIMIT, "Consumer name", "255");
 396         }
 397
 398         @Test
 399         public void createEcompCredentialsUserNameLastCharIsDash() throws Exception { // allowed
 400                 consumerDataDefinition.setConsumerName("ABCD34567890pf34567890poiutrew-");
 401                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 402                                 sdncAdminUserDetails);
 403                 assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
 404                                 createConsumerRest.getErrorCode().intValue());
 405                 // parse updated response to javaObject , Validate actual consumerData
 406                 // to returned from response
 407                 ConsumerDataDefinition getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(createConsumerRest);
 408                 ConsumerRestUtils.validateConsumerReqVsResp(consumerDataDefinition, getConsumerDataObject);
 409                 // Get Consumer
 410                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 411                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
 412                                 getConsumerRest.getErrorCode().intValue());
 413                 getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(getConsumerRest);
 414                 ConsumerRestUtils.validateConsumerReqVsResp(consumerDataDefinition, getConsumerDataObject);
 415                 // Audit validation
 416                 AuditValidationUtils.ecompConsumerAuditSuccess(ADD_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
 417                                 sdncAdminUserDetails, STATUS_CODE_SUCSESS_CREATED);
 418                 // Delete Consumer
 419                 ConsumerRestUtils.deleteConsumer(consumerDataDefinition, sdncAdminUserDetails);
 420         }
 421
 422         @Test
 423         public void createEcompCredentialsUserNameLastCharIsPeriod() throws Exception {
 424                 consumerDataDefinition.setConsumerName("ABCD34567890pf34567890poiutrew.");
 425                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 426                                 sdncAdminUserDetails);
 427                 assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
 428                                 createConsumerRest.getErrorCode().intValue());
 429                 // parse updated response to javaObject , Validate actual consumerData
 430                 // to returned from response
 431                 ConsumerDataDefinition getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(createConsumerRest);
 432                 ConsumerRestUtils.validateConsumerReqVsResp(consumerDataDefinition, getConsumerDataObject);
 433                 // Get Consumer
 434                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 435                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
 436                                 getConsumerRest.getErrorCode().intValue());
 437                 getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(getConsumerRest);
 438                 ConsumerRestUtils.validateConsumerReqVsResp(consumerDataDefinition, getConsumerDataObject);
 439                 // Audit validation
 440                 AuditValidationUtils.ecompConsumerAuditSuccess(ADD_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
 441                                 sdncAdminUserDetails, STATUS_CODE_SUCSESS_CREATED);
 442                 // Delete Consumer
 443                 ConsumerRestUtils.deleteConsumer(consumerDataDefinition, sdncAdminUserDetails);
 444         }
 445
 446         @Test
 447         public void createEcompCredentialsUserNameLastCharIsUnderscore() throws Exception {
 448                 consumerDataDefinition.setConsumerName("ABCD34567890pf34567890poiutrew_");
 449                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 450                                 sdncAdminUserDetails);
 451                 assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
 452                                 createConsumerRest.getErrorCode().intValue());
 453                 // parse updated response to javaObject , Validate actual consumerData
 454                 // to returned from response
 455                 ConsumerDataDefinition getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(createConsumerRest);
 456                 ConsumerRestUtils.validateConsumerReqVsResp(consumerDataDefinition, getConsumerDataObject);
 457                 // Get Consumer
 458                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 459                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
 460                                 getConsumerRest.getErrorCode().intValue());
 461                 getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(getConsumerRest);
 462                 ConsumerRestUtils.validateConsumerReqVsResp(consumerDataDefinition, getConsumerDataObject);
 463                 // Audit validation
 464                 AuditValidationUtils.ecompConsumerAuditSuccess(ADD_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
 465                                 sdncAdminUserDetails, STATUS_CODE_SUCSESS_CREATED);
 466                 // Delete Consumer
 467                 ConsumerRestUtils.deleteConsumer(consumerDataDefinition, sdncAdminUserDetails);
 468         }
 469
 470         @Test
 471         public void createEcompCredentialsUserNameFirstCharIsUnderscore() throws Exception {
 472                 consumerDataDefinition.setConsumerName("_ABCD34567890pf34567890poiutre");
 473                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 474                                 sdncAdminUserDetails);
 475                 assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
 476                                 createConsumerRest.getErrorCode().intValue());
 477                 // parse updated response to javaObject , Validate actual consumerData
 478                 // to returned from response
 479                 ConsumerDataDefinition getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(createConsumerRest);
 480                 ConsumerRestUtils.validateConsumerReqVsResp(consumerDataDefinition, getConsumerDataObject);
 481                 // Get Consumer
 482                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 483                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
 484                                 getConsumerRest.getErrorCode().intValue());
 485                 getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(getConsumerRest);
 486                 ConsumerRestUtils.validateConsumerReqVsResp(consumerDataDefinition, getConsumerDataObject);
 487                 // Audit validation
 488                 AuditValidationUtils.ecompConsumerAuditSuccess(ADD_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
 489                                 sdncAdminUserDetails, STATUS_CODE_SUCSESS_CREATED);
 490                 // Delete Consumer
 491                 ConsumerRestUtils.deleteConsumer(consumerDataDefinition, sdncAdminUserDetails);
 492         }
 493
 494         @Test
 495         public void createEcompCredentialsUserNameFirstCharIsPeriod() throws Exception {
 496                 consumerDataDefinition.setConsumerName(".ABCD34567890pf34567890poiutre");
 497                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 498                                 sdncAdminUserDetails);
 499                 assertEquals("Check response code after create Consumer", STATUS_CODE_INVALID_CONTENT,
 500                                 createConsumerRest.getErrorCode().intValue());
 501                 // verify that consumer didn't created
 502                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 503                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
 504                                 getConsumerRest.getErrorCode().intValue());
 505                 // Audit validation
 506                 AuditValidationUtils.createEcompConsumerAuditFailure(ADD_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
 507                                 sdncAdminUserDetails, ActionStatus.INVALID_CONTENT_PARAM, "Consumer name");
 508         }
 509
 510         @Test
 511         public void createEcompCredentialsUserNameFirstCharIsDash() throws Exception { // Not
 512                                                                                                                                                                         // allowed
 513                 consumerDataDefinition.setConsumerName("-ABCD34567890pf34567890poiutre");
 514                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 515                                 sdncAdminUserDetails);
 516                 assertEquals("Check response code after create Consumer", STATUS_CODE_INVALID_CONTENT,
 517                                 createConsumerRest.getErrorCode().intValue());
 518                 // verify that consumer didn't created
 519                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 520                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
 521                                 getConsumerRest.getErrorCode().intValue());
 522                 // Audit validation
 523                 AuditValidationUtils.createEcompConsumerAuditFailure(ADD_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
 524                                 sdncAdminUserDetails, ActionStatus.INVALID_CONTENT_PARAM, "Consumer name");
 525         }
 526
 527         /// Password
 528         @Test
 529         public void createEcompCredentialsPasswordIsNull() throws Exception {
 530                 consumerDataDefinition.setConsumerPassword(null);
 531                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 532                                 sdncAdminUserDetails);
 533                 assertEquals("Check response code after create Consumer", STATUS_CODE_MISSING_DATA,
 534                                 createConsumerRest.getErrorCode().intValue());
 535                 // verify taht consumer didn't created
 536                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 537                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
 538                                 getConsumerRest.getErrorCode().intValue());
 539                 // validate audit
 540                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_DATA.name());
 541                 ExpectedEcomConsumerAudit expectedEcomConsumerAuditJavaObject = new ExpectedEcomConsumerAudit();
 542                 expectedEcomConsumerAuditJavaObject.setAction(ADD_ECOMP_USER_CREDENTIALS);
 543                 expectedEcomConsumerAuditJavaObject.setEcomUser(consumerDataDefinition.getConsumerName() + ","
 544                                 + consumerDataDefinition.getConsumerSalt().toLowerCase());
 545                 expectedEcomConsumerAuditJavaObject.setStatus(errorInfo.getCode().toString());
 546                 expectedEcomConsumerAuditJavaObject.setDesc(errorInfo.getAuditDesc("Consumer password"));
 547                 expectedEcomConsumerAuditJavaObject
 548                                 .setModifier(sdncAdminUserDetails.getFullName() + "(" + sdncAdminUserDetails.getUserId() + ")");
 549                 AuditValidationUtils.validateEcompConsumerAudit(expectedEcomConsumerAuditJavaObject,
 550                                 ADD_ECOMP_USER_CREDENTIALS);
 551         }
 552
 553         @Test
 554         public void createEcompCredentialsPasswordIsEmpty() throws Exception {
 555                 consumerDataDefinition.setConsumerPassword("");
 556                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 557                                 sdncAdminUserDetails);
 558                 assertEquals("Check response code after create Consumer", STATUS_CODE_MISSING_DATA,
 559                                 createConsumerRest.getErrorCode().intValue());
 560                 // verify taht consumer didn't created
 561                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 562                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
 563                                 getConsumerRest.getErrorCode().intValue());
 564                 // validate audit
 565                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_DATA.name());
 566                 ExpectedEcomConsumerAudit expectedEcomConsumerAuditJavaObject = new ExpectedEcomConsumerAudit();
 567                 expectedEcomConsumerAuditJavaObject.setAction(ADD_ECOMP_USER_CREDENTIALS);
 568                 expectedEcomConsumerAuditJavaObject.setEcomUser(consumerDataDefinition.getConsumerName() + ","
 569                                 + consumerDataDefinition.getConsumerSalt().toLowerCase());
 570                 expectedEcomConsumerAuditJavaObject.setStatus(errorInfo.getCode().toString());
 571                 expectedEcomConsumerAuditJavaObject.setDesc(errorInfo.getAuditDesc("Consumer password"));
 572                 expectedEcomConsumerAuditJavaObject
 573                                 .setModifier(sdncAdminUserDetails.getFullName() + "(" + sdncAdminUserDetails.getUserId() + ")");
 574                 AuditValidationUtils.validateEcompConsumerAudit(expectedEcomConsumerAuditJavaObject,
 575                                 ADD_ECOMP_USER_CREDENTIALS);
 576         }
 577
 578         @Test
 579         public void createEcompCredentialsPasswordMaxLength() throws Exception { // password
 580                                                                                                                                                                 // must
 581                                                                                                                                                                 // be
 582                                                                                                                                                                 // 64
 583                                                                                                                                                                 // chars
 584                 consumerDataDefinition.setConsumerPassword("123456789012345678901234567890ab123456789012345678901234567890ab");
 585                 // Create Consumer
 586                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 587                                 sdncAdminUserDetails);
 588                 assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
 589                                 createConsumerRest.getErrorCode().intValue());
 590                 // parse updated response to javaObject
 591                 ConsumerDataDefinition getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(createConsumerRest);
 592                 // Validate actual consumerData to returned from response
 593                 ConsumerRestUtils.validateConsumerReqVsResp(consumerDataDefinition, getConsumerDataObject);
 594                 // Get Consumer
 595                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 596                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
 597                                 getConsumerRest.getErrorCode().intValue());
 598                 getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(getConsumerRest);
 599                 ConsumerRestUtils.validateConsumerReqVsResp(consumerDataDefinition, getConsumerDataObject);
 600                 // Audit validation
 601                 AuditValidationUtils.ecompConsumerAuditSuccess(ADD_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
 602                                 sdncAdminUserDetails, STATUS_CODE_SUCSESS_CREATED);
 603                 // Delete Consumer
 604                 ConsumerRestUtils.deleteConsumer(consumerDataDefinition, sdncAdminUserDetails);
 605         }
 606
 607         @Test
 608         public void createEcompCredentialsPasswordExceeedMaxLength() throws Exception { // password
 609                                                                                                                                                                         // must
 610                                                                                                                                                                         // be
 611                                                                                                                                                                         // 64
 612                                                                                                                                                                         // chars
 613                 consumerDataDefinition.setConsumerPassword("123456789012345678901234567890ab123456789012345678901234567890ab1");
 614                 // Create Consumer
 615                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 616                                 sdncAdminUserDetails);
 617                 assertEquals("Check response code after create Consumer", STATUS_CODE_INVALID_CONTENT,
 618                                 createConsumerRest.getErrorCode().intValue());
 619                 // verify that consumer didn't created
 620                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 621                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
 622                                 getConsumerRest.getErrorCode().intValue());
 623                 // Audit validation
 624                 AuditValidationUtils.createEcompConsumerAuditFailure(ADD_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
 625                                 sdncAdminUserDetails, ActionStatus.INVALID_LENGTH, "Consumer password", "64");
 626         }
 627
 628         @Test
 629         public void createEcompCredentiaPasswordValid() throws Exception {
 630                 // Password Contains lowercase/uppercase characters and numbers -
 631                 // convert upper case letter to lower
 632                 consumerDataDefinition.setConsumerPassword("ABCabc1234567890POImnb12345678901234567890POIUzxcvbNMASDFGhjkl12");
 633                 // Create Consumer
 634                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 635                                 sdncAdminUserDetails);
 636                 assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
 637                                 createConsumerRest.getErrorCode().intValue());
 638                 ConsumerDataDefinition getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(createConsumerRest);
 639                 ConsumerRestUtils.validateConsumerReqVsResp(consumerDataDefinition, getConsumerDataObject);
 640                 // Get Consumer
 641                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 642                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
 643                                 getConsumerRest.getErrorCode().intValue());
 644                 getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(getConsumerRest);
 645                 ConsumerRestUtils.validateConsumerReqVsResp(consumerDataDefinition, getConsumerDataObject);
 646                 AuditValidationUtils.ecompConsumerAuditSuccess(ADD_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
 647                                 sdncAdminUserDetails, STATUS_CODE_SUCSESS_CREATED);
 648
 649         }
 650
 651         //// Salt
 652         @Test
 653         public void createEcompCredentialsSaltIsNull() throws Exception {
 654                 // Length must be 32 characters
 655                 consumerDataDefinition.setConsumerSalt(null);
 656                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 657                                 sdncAdminUserDetails);
 658                 assertEquals("Check response code after create Consumer", STATUS_CODE_MISSING_DATA,
 659                                 createConsumerRest.getErrorCode().intValue());
 660                 // verify that consumer didn't created
 661                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 662                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
 663                                 getConsumerRest.getErrorCode().intValue());
 664                 // validate audit
 665                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_DATA.name());
 666                 ExpectedEcomConsumerAudit expectedEcomConsumerAuditJavaObject = new ExpectedEcomConsumerAudit();
 667                 expectedEcomConsumerAuditJavaObject.setAction(ADD_ECOMP_USER_CREDENTIALS);
 668                 expectedEcomConsumerAuditJavaObject.setEcomUser(consumerDataDefinition.getConsumerName() + ","
 669                                 + consumerDataDefinition.getConsumerPassword().toLowerCase());
 670                 expectedEcomConsumerAuditJavaObject.setStatus(errorInfo.getCode().toString());
 671                 expectedEcomConsumerAuditJavaObject.setDesc(errorInfo.getAuditDesc("Consumer salt"));
 672                 expectedEcomConsumerAuditJavaObject
 673                                 .setModifier(sdncAdminUserDetails.getFullName() + "(" + sdncAdminUserDetails.getUserId() + ")");
 674                 AuditValidationUtils.validateEcompConsumerAudit(expectedEcomConsumerAuditJavaObject,
 675                                 ADD_ECOMP_USER_CREDENTIALS);
 676
 677         }
 678
 679         @Test
 680         public void createEcompCredentialsSaltIsEmpty() throws Exception {
 681                 consumerDataDefinition.setConsumerSalt("");
 682                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 683                                 sdncAdminUserDetails);
 684                 assertEquals("Check response code after create Consumer", STATUS_CODE_MISSING_DATA,
 685                                 createConsumerRest.getErrorCode().intValue());
 686                 // verify that consumer didn't created
 687                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 688                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
 689                                 getConsumerRest.getErrorCode().intValue());
 690                 // validate audit
 691                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_DATA.name());
 692                 ExpectedEcomConsumerAudit expectedEcomConsumerAuditJavaObject = new ExpectedEcomConsumerAudit();
 693                 expectedEcomConsumerAuditJavaObject.setAction(ADD_ECOMP_USER_CREDENTIALS);
 694                 expectedEcomConsumerAuditJavaObject.setEcomUser(consumerDataDefinition.getConsumerName() + ","
 695                                 + consumerDataDefinition.getConsumerPassword().toLowerCase());
 696                 expectedEcomConsumerAuditJavaObject.setStatus(errorInfo.getCode().toString());
 697                 expectedEcomConsumerAuditJavaObject.setDesc(errorInfo.getAuditDesc("Consumer salt"));
 698                 expectedEcomConsumerAuditJavaObject
 699                                 .setModifier(sdncAdminUserDetails.getFullName() + "(" + sdncAdminUserDetails.getUserId() + ")");
 700                 AuditValidationUtils.validateEcompConsumerAudit(expectedEcomConsumerAuditJavaObject,
 701                                 ADD_ECOMP_USER_CREDENTIALS);
 702         }
 703
 704         @Test
 705         public void createEcompCredentialsSaltLengthLessThan32() throws Exception {
 706                 consumerDataDefinition.setConsumerSalt("123456789012345678901234567890a");
 707                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 708                                 sdncAdminUserDetails);
 709                 assertEquals("Check response code after create Consumer", STATUS_CODE_INVALID_CONTENT,
 710                                 createConsumerRest.getErrorCode().intValue());
 711                 // verify that consumer didn't created
 712                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 713                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
 714                                 getConsumerRest.getErrorCode().intValue());
 715                 // Audit validation
 716                 AuditValidationUtils.createEcompConsumerAuditFailure(ADD_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
 717                                 sdncAdminUserDetails, ActionStatus.INVALID_LENGTH, "Consumer salt");
 718
 719         }
 720
 721         // Bug
 722         @Test
 723         public void createEcompCredentialsSaltLengthMoreThan32() throws Exception { // Length
 724                                                                                                                                                                 // must
 725                                                                                                                                                                 // be
 726                                                                                                                                                                 // 32
 727                                                                                                                                                                 // characters
 728                                                                                                                                                                 // -
 729                                                                                                                                                                 // SVC4529
 730                                                                                                                                                                 // "Error:
 731                                                                                                                                                                 // Invalid
 732                                                                                                                                                                 // Content.
 733                                                                                                                                                                 // %1
 734                                                                                                                                                                 // exceeds
 735                                                                                                                                                                 // limit
 736                                                                                                                                                                 // of
 737                                                                                                                                                                 // %2
 738                                                                                                                                                                 // characters."
 739                 consumerDataDefinition.setConsumerSalt("123456789012345678901234567890abc");
 740                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 741                                 sdncAdminUserDetails);
 742                 assertEquals("Check response code after create Consumer", STATUS_CODE_INVALID_CONTENT,
 743                                 createConsumerRest.getErrorCode().intValue());
 744                 // verify that consumer didn't created
 745                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 746                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
 747                                 getConsumerRest.getErrorCode().intValue());
 748                 // Audit validation
 749                 AuditValidationUtils.createEcompConsumerAuditFailure(ADD_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
 750                                 sdncAdminUserDetails, ActionStatus.INVALID_LENGTH, "Consumer salt");
 751
 752         }
 753
 754         @Test
 755         public void createEcompCredentialsSaltUppercaseCharacters() throws Exception {
 756                 // Contains uppercase characters– exception invalid content
 757                 consumerDataDefinition.setConsumerSalt("123456789012345678901234567890AB");
 758                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 759                                 sdncAdminUserDetails);
 760                 assertEquals("Check response code after create Consumer", STATUS_CODE_INVALID_CONTENT,
 761                                 createConsumerRest.getErrorCode().intValue());
 762                 // verify that consumer didn't created
 763                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 764                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
 765                                 getConsumerRest.getErrorCode().intValue());
 766                 // Audit validation
 767                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.INVALID_CONTENT_PARAM.name());
 768                 ExpectedEcomConsumerAudit expectedEcomConsumerAuditJavaObject = new ExpectedEcomConsumerAudit();
 769                 expectedEcomConsumerAuditJavaObject.setAction(ADD_ECOMP_USER_CREDENTIALS);
 770                 expectedEcomConsumerAuditJavaObject.setEcomUser(consumerDataDefinition.getConsumerName() + ","
 771                                 + consumerDataDefinition.getConsumerSalt() + "," + consumerDataDefinition.getConsumerPassword());
 772                 expectedEcomConsumerAuditJavaObject.setStatus(errorInfo.getCode().toString());
 773                 expectedEcomConsumerAuditJavaObject.setDesc(errorInfo.getAuditDesc("Consumer salt"));
 774                 expectedEcomConsumerAuditJavaObject
 775                                 .setModifier(sdncAdminUserDetails.getFullName() + "(" + sdncAdminUserDetails.getUserId() + ")");
 776                 AuditValidationUtils.validateEcompConsumerAudit(expectedEcomConsumerAuditJavaObject,
 777                                 ADD_ECOMP_USER_CREDENTIALS);
 778         }
 779
 780         // UserId (UserId is taken from USER_ID header)
 781
 782         @Test
 783         public void createEcompCredentialsHttpCspUserIdIsEmpty() throws Exception {
 784                 // UserId is taken from USER_ID header
 785                 sdncAdminUserDetails.setUserId("");
 786                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 787                                 sdncAdminUserDetails);
 788                 assertEquals("Check response code after create Consumer", STATUS_CODE_MISSING_INFORMATION,
 789                                 createConsumerRest.getErrorCode().intValue());
 790                 // Audit validation
 791                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_INFORMATION.name());
 792                 ExpectedEcomConsumerAudit expectedEcomConsumerAuditJavaObject = new ExpectedEcomConsumerAudit();
 793                 expectedEcomConsumerAuditJavaObject.setAction(ADD_ECOMP_USER_CREDENTIALS);
 794                 expectedEcomConsumerAuditJavaObject.setEcomUser(consumerDataDefinition.getConsumerName() + ","
 795                                 + consumerDataDefinition.getConsumerSalt() + "," + consumerDataDefinition.getConsumerPassword());
 796                 expectedEcomConsumerAuditJavaObject.setStatus(errorInfo.getCode().toString());
 797                 expectedEcomConsumerAuditJavaObject.setDesc(errorInfo.getAuditDesc("Consumer salt"));
 798                 expectedEcomConsumerAuditJavaObject.setModifier("");
 799                 AuditValidationUtils.validateEcompConsumerAudit(expectedEcomConsumerAuditJavaObject,
 800                                 ADD_ECOMP_USER_CREDENTIALS);
 801         }
 802
 803         @Test
 804         public void createEcompCredentialsHttpCspUserIdIsNull() throws Exception { // UserId
 805                                                                                                                                                                 // is
 806                                                                                                                                                                 // taken
 807                                                                                                                                                                 // from
 808                                                                                                                                                                 // USER_ID
 809                                                                                                                                                                 // header
 810                 sdncAdminUserDetails.setUserId(null);
 811                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 812                                 sdncAdminUserDetails);
 813                 assertEquals("Check response code after create Consumer", STATUS_CODE_MISSING_INFORMATION,
 814                                 createConsumerRest.getErrorCode().intValue());
 815                 // Audit validation
 816                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_INFORMATION.name());
 817                 ExpectedEcomConsumerAudit expectedEcomConsumerAuditJavaObject = new ExpectedEcomConsumerAudit();
 818                 expectedEcomConsumerAuditJavaObject.setAction(ADD_ECOMP_USER_CREDENTIALS);
 819                 expectedEcomConsumerAuditJavaObject.setEcomUser(consumerDataDefinition.getConsumerName() + ","
 820                                 + consumerDataDefinition.getConsumerSalt() + "," + consumerDataDefinition.getConsumerPassword());
 821                 expectedEcomConsumerAuditJavaObject.setStatus(errorInfo.getCode().toString());
 822                 expectedEcomConsumerAuditJavaObject.setDesc(errorInfo.getAuditDesc("Consumer salt"));
 823                 expectedEcomConsumerAuditJavaObject.setModifier("");
 824                 AuditValidationUtils.validateEcompConsumerAudit(expectedEcomConsumerAuditJavaObject,
 825                                 ADD_ECOMP_USER_CREDENTIALS);
 826         }
 827
 828         @Test
 829         public void createEcompCredentialsHttpCspUserIdHeaderIsMissing() throws Exception {
 830                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumerHttpCspAtuUidIsMissing(consumerDataDefinition,
 831                                 sdncAdminUserDetails);
 832                 assertEquals("Check response code after create Consumer", STATUS_CODE_MISSING_INFORMATION,
 833                                 createConsumerRest.getErrorCode().intValue());
 834                 // Audit validation
 835                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_INFORMATION.name());
 836                 ExpectedEcomConsumerAudit expectedEcomConsumerAuditJavaObject = new ExpectedEcomConsumerAudit();
 837                 expectedEcomConsumerAuditJavaObject.setAction(ADD_ECOMP_USER_CREDENTIALS);
 838                 expectedEcomConsumerAuditJavaObject.setEcomUser(consumerDataDefinition.getConsumerName() + ","
 839                                 + consumerDataDefinition.getConsumerSalt() + "," + consumerDataDefinition.getConsumerPassword());
 840                 expectedEcomConsumerAuditJavaObject.setStatus(errorInfo.getCode().toString());
 841                 expectedEcomConsumerAuditJavaObject.setDesc(errorInfo.getAuditDesc("Consumer salt"));
 842                 expectedEcomConsumerAuditJavaObject.setModifier("");
 843                 AuditValidationUtils.validateEcompConsumerAudit(expectedEcomConsumerAuditJavaObject,
 844                                 ADD_ECOMP_USER_CREDENTIALS);
 845         }
 846
 847         // add UserId in json body
 848         @Test
 849         public void createEcompCredentiaJsonBodyContainLastModfierAtuid() throws Exception {
 850                 // Add UserId (not admin) to json - we will ignore and create the user
 851                 HashMap<String, String> jsonMap = new HashMap<String, String>();
 852                 jsonMap.put("consumerName", "benny");
 853                 jsonMap.put("consumerPassword", "123456789012345678901234567890ab123456789012345678901234567890ab");
 854                 jsonMap.put("consumerSalt", "123456789012345678901234567890ab");
 855                 jsonMap.put("lastModfierAtuid", "cs0008"); // designer
 856                 Gson gson = new Gson();
 857                 ConsumerDataDefinition consumer = gson.fromJson(jsonMap.toString(), ConsumerDataDefinition.class);
 858
 859                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumer, sdncAdminUserDetails);
 860                 assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
 861                                 createConsumerRest.getErrorCode().intValue());
 862                 // Validate actual consumerData to returned from response
 863                 ConsumerDataDefinition getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(createConsumerRest);
 864                 ConsumerRestUtils.validateConsumerReqVsResp(consumer, getConsumerDataObject);
 865                 // Get Consumer
 866                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 867                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
 868                                 getConsumerRest.getErrorCode().intValue());
 869                 getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(getConsumerRest);
 870                 ConsumerRestUtils.validateConsumerReqVsResp(consumer, getConsumerDataObject);
 871                 // Audit validation
 872                 AuditValidationUtils.ecompConsumerAuditSuccess(ADD_ECOMP_USER_CREDENTIALS, consumer, sdncAdminUserDetails,
 873                                 STATUS_CODE_SUCSESS_CREATED);
 874                 // Delete consumer
 875                 ConsumerRestUtils.deleteConsumer(consumer, sdncAdminUserDetails);
 876         }
 877
 878         @Test
 879         public void createEcompCredentialsUserNameNotAllowedCharacters() throws Exception {
 880                 char invalidChars[] = { '`', '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '+', '=', '<', '>', '?', '/',
 881                                 '"', ':', '}', ']', '[', '{', '|', '\\', ' ', '\t', '\n' };
 882                 for (int i = 0; i < invalidChars.length; i++) {
 883                         DbUtils.deleteFromEsDbByPattern("_all");
 884                         consumerDataDefinition.setConsumerName(invalidChars[i] + "ABCdef123");
 885                         RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 886                                         sdncAdminUserDetails);
 887                         assertEquals("Check response code after create Consumer", STATUS_CODE_INVALID_CONTENT,
 888                                         createConsumerRest.getErrorCode().intValue());
 889                         // Audit validation
 890                         AuditValidationUtils.createEcompConsumerAuditFailure(ADD_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
 891                                         sdncAdminUserDetails, ActionStatus.INVALID_CONTENT_PARAM, "Consumer name");
 892                 }
 893         }
 894
 895         @Test
 896         public void createEcompCredentialsPasswordIsInvalid() throws Exception {
 897                 char invalidChars[] = { '`', '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '+', '=', '<', '>', '?', '/',
 898                                 '"', ':', '}', ']', '[', '{', '|', '\\', ' ', '\t', '\n' };
 899                 for (int i = 0; i < invalidChars.length; i++) {
 900                         DbUtils.deleteFromEsDbByPattern("_all");
 901                         consumerDataDefinition.setConsumerPassword(
 902                                         "ABC" + invalidChars[i] + "ABCabc1234567890POImnb12345678901234567890POIUzxcvbNMASDFGhj");
 903                         RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 904                                         sdncAdminUserDetails);
 905                         assertEquals("Check response code after create Consumer", STATUS_CODE_INVALID_CONTENT,
 906                                         createConsumerRest.getErrorCode().intValue());
 907                         // Audit validation
 908                         AuditValidationUtils.createEcompConsumerAuditFailure(ADD_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
 909                                         sdncAdminUserDetails, ActionStatus.INVALID_CONTENT_PARAM, "Consumer password");
 910                 }
 911         }
 912
 913         @Test
 914         public void createEcompCredentialsSaltNotAllowedCharacters() throws Exception { // Salt
 915                                                                                                                                                                         // must
 916                                                                                                                                                                         // be
 917                                                                                                                                                                         // 32
 918                                                                                                                                                                         // chars
 919                 char invalidChars[] = { '`', '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '+', '=', '<', '>', '?', '/',
 920                                 '"', ':', '}', ']', '[', '{', '|', '\\', ' ', '\t', '\n' };
 921                 for (int i = 0; i < invalidChars.length; i++) {
 922                         DbUtils.deleteFromEsDbByPattern("_all");
 923                         consumerDataDefinition.setConsumerSalt(invalidChars[i] + "1234567890123456789012345678901");
 924                         RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 925                                         sdncAdminUserDetails);
 926                         assertEquals("Check response code after create Consumer", STATUS_CODE_INVALID_CONTENT,
 927                                         createConsumerRest.getErrorCode().intValue());
 928                         // Audit validation
 929                         AuditValidationUtils.createEcompConsumerAuditFailure(ADD_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
 930                                         sdncAdminUserDetails, ActionStatus.INVALID_CONTENT_PARAM, "Consumer salt");
 931                 }
 932         }
 933
 934         @Test
 935         public void createEcompCredentialsPasswordEncoded() throws Exception {
 936                 consumerDataDefinition.setConsumerPassword("0a0dc557c3bf594b1a48030e3e99227580168b21f44e285c69740b8d5b13e33b");
 937                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 938                                 sdncAdminUserDetails);
 939                 assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
 940                                 createConsumerRest.getErrorCode().intValue());
 941                 // parse updated response to javaObject
 942                 ConsumerDataDefinition getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(createConsumerRest);
 943                 // Validate actual consumerData to returned from response
 944                 ConsumerRestUtils.validateConsumerReqVsResp(consumerDataDefinition, getConsumerDataObject);
 945
 946                 // Get Consumer
 947                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 948                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
 949                                 getConsumerRest.getErrorCode().intValue());
 950                 getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(getConsumerRest);
 951                 ConsumerRestUtils.validateConsumerReqVsResp(consumerDataDefinition, getConsumerDataObject);
 952                 // Audit validation
 953                 AuditValidationUtils.ecompConsumerAuditSuccess(ADD_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
 954                                 sdncAdminUserDetails, STATUS_CODE_SUCSESS_CREATED);
 955         }
 956
 957         //
 958
 959         @Test
 960         public void deleteEcompUserAlreayDeleted() throws Exception {
 961                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 962                                 sdncAdminUserDetails);
 963                 assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
 964                                 createConsumerRest.getErrorCode().intValue());
 965                 // Get Consumer
 966                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 967                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
 968                                 getConsumerRest.getErrorCode().intValue());
 969                 // Delete ECOMP consumer
 970                 RestResponse deleteConsumerRest = ConsumerRestUtils.deleteConsumer(consumerDataDefinition,
 971                                 sdncAdminUserDetails);
 972                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS_DELETE_GET,
 973                                 deleteConsumerRest.getErrorCode().intValue());
 974                 // Try to delete ECOMP consumer already deleted
 975                 DbUtils.deleteFromEsDbByPattern("_all");
 976                 deleteConsumerRest = ConsumerRestUtils.deleteConsumer(consumerDataDefinition, sdncAdminUserDetails);
 977                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
 978                                 deleteConsumerRest.getErrorCode().intValue());
 979                 // Audit validation
 980                 AuditValidationUtils.deleteEcompConsumerAuditFailure(DELETE_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
 981                                 sdncAdminUserDetails, ActionStatus.ECOMP_USER_NOT_FOUND, consumerDataDefinition.getConsumerName());
 982         }
 983
 984         @Test
 985         public void deleteEcompUserByTester() throws Exception {
 986                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
 987                                 sdncAdminUserDetails);
 988                 assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
 989                                 createConsumerRest.getErrorCode().intValue());
 990                 // Get Consumer
 991                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
 992                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
 993                                 getConsumerRest.getErrorCode().intValue());
 994                 // Delete consumer
 995                 DbUtils.deleteFromEsDbByPattern("_all");
 996                 RestResponse deleteConsumerRest = ConsumerRestUtils.deleteConsumer(consumerDataDefinition,
 997                                 sdncTesterUserDetails);
 998                 assertEquals("Check response code after get Consumer", STATUS_CODE_RESTRICTED_OPERATION,
 999                                 deleteConsumerRest.getErrorCode().intValue());
1000                 // Audit validation
1001                 AuditValidationUtils.deleteEcompConsumerAuditFailure(DELETE_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
1002                                 sdncTesterUserDetails, ActionStatus.RESTRICTED_OPERATION);
1003                 // Verify that consumer is not deleted
1004                 getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
1005                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
1006                                 getConsumerRest.getErrorCode().intValue());
1007         }
1008
1009         @Test
1010         public void deleteEcompUserByOps() throws Exception {
1011                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
1012                                 sdncAdminUserDetails);
1013                 assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
1014                                 createConsumerRest.getErrorCode().intValue());
1015                 // Get Consumer
1016                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
1017                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
1018                                 getConsumerRest.getErrorCode().intValue());
1019                 // Delete consumer
1020                 DbUtils.deleteFromEsDbByPattern("_all");
1021                 RestResponse deleteConsumerRest = ConsumerRestUtils.deleteConsumer(consumerDataDefinition, sdncOpsUserDetails);
1022                 assertEquals("Check response code after get Consumer", STATUS_CODE_RESTRICTED_OPERATION,
1023                                 deleteConsumerRest.getErrorCode().intValue());
1024                 // Audit validation
1025                 AuditValidationUtils.deleteEcompConsumerAuditFailure(DELETE_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
1026                                 sdncOpsUserDetails, ActionStatus.RESTRICTED_OPERATION);
1027                 // Verify that consumer is not deleted
1028                 getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
1029                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
1030                                 getConsumerRest.getErrorCode().intValue());
1031         }
1032
1033         @Test
1034         public void deleteEcompUserByGovernor() throws Exception {
1035                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
1036                                 sdncAdminUserDetails);
1037                 assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
1038                                 createConsumerRest.getErrorCode().intValue());
1039                 // Get Consumer
1040                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
1041                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
1042                                 getConsumerRest.getErrorCode().intValue());
1043                 // Delete consumer
1044                 DbUtils.deleteFromEsDbByPattern("_all");
1045                 RestResponse deleteConsumerRest = ConsumerRestUtils.deleteConsumer(consumerDataDefinition,
1046                                 sdncGovernorUserDetails);
1047                 assertEquals("Check response code after get Consumer", STATUS_CODE_RESTRICTED_OPERATION,
1048                                 deleteConsumerRest.getErrorCode().intValue());
1049                 // Audit validation
1050                 AuditValidationUtils.deleteEcompConsumerAuditFailure(DELETE_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
1051                                 sdncGovernorUserDetails, ActionStatus.RESTRICTED_OPERATION);
1052                 // Verify that consumer is not deleted
1053                 getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
1054                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
1055                                 getConsumerRest.getErrorCode().intValue());
1056         }
1057
1058         @Test
1059         public void deleteEcompUserByDesigner() throws Exception {
1060                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
1061                                 sdncAdminUserDetails);
1062                 assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
1063                                 createConsumerRest.getErrorCode().intValue());
1064                 // Get Consumer
1065                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
1066                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
1067                                 getConsumerRest.getErrorCode().intValue());
1068                 // Delete consumer
1069                 DbUtils.deleteFromEsDbByPattern("_all");
1070                 RestResponse deleteConsumerRest = ConsumerRestUtils.deleteConsumer(consumerDataDefinition,
1071                                 sdncDesignerUserDetails);
1072                 assertEquals("Check response code after get Consumer", STATUS_CODE_RESTRICTED_OPERATION,
1073                                 deleteConsumerRest.getErrorCode().intValue());
1074                 // Audit validation
1075                 AuditValidationUtils.deleteEcompConsumerAuditFailure(DELETE_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
1076                                 sdncDesignerUserDetails, ActionStatus.RESTRICTED_OPERATION);
1077                 // Verify that consumer is not deleted
1078                 getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
1079                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
1080                                 getConsumerRest.getErrorCode().intValue());
1081         }
1082
1083         @Test
1084         public void deleteEcompUserByNoExistingIUser() throws Exception {
1085                 User noSdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1086                 noSdncUserDetails.setRole("blabla");
1087                 noSdncUserDetails.setUserId("bt750h");
1088                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
1089                                 sdncAdminUserDetails);
1090                 assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
1091                                 createConsumerRest.getErrorCode().intValue());
1092                 // Get Consumer
1093                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
1094                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
1095                                 getConsumerRest.getErrorCode().intValue());
1096                 // Delete consumer
1097                 DbUtils.deleteFromEsDbByPattern("_all");
1098                 RestResponse deleteConsumerRest = ConsumerRestUtils.deleteConsumer(consumerDataDefinition, noSdncUserDetails);
1099                 assertEquals("Check response code after get Consumer", STATUS_CODE_RESTRICTED_ACCESS,
1100                                 deleteConsumerRest.getErrorCode().intValue());
1101                 // Audit validation
1102                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_ACCESS.name());
1103                 ExpectedEcomConsumerAudit expectedEcomConsumerAuditJavaObject = new ExpectedEcomConsumerAudit();
1104                 expectedEcomConsumerAuditJavaObject.setAction(ADD_ECOMP_USER_CREDENTIALS);
1105                 expectedEcomConsumerAuditJavaObject.setEcomUser(consumerDataDefinition.getConsumerName());
1106                 expectedEcomConsumerAuditJavaObject.setStatus(errorInfo.getCode().toString());
1107                 expectedEcomConsumerAuditJavaObject.setDesc(errorInfo.getAuditDesc(""));
1108                 expectedEcomConsumerAuditJavaObject.setModifier("(" + noSdncUserDetails.getUserId() + ")");
1109                 AuditValidationUtils.validateEcompConsumerAudit(expectedEcomConsumerAuditJavaObject,
1110                                 DELETE_ECOMP_USER_CREDENTIALS);
1111                 // Verify that consumer is not deleted
1112                 getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
1113                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
1114                                 getConsumerRest.getErrorCode().intValue());
1115         }
1116
1117         @Test
1118         public void deleteEcompCredentialsUserDoesNotExist() throws Exception {
1119                 DbUtils.deleteFromEsDbByPattern("_all");
1120                 RestResponse deleteConsumerRest = ConsumerRestUtils.deleteConsumer(consumerDataDefinition,
1121                                 sdncAdminUserDetails);
1122                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
1123                                 deleteConsumerRest.getErrorCode().intValue());
1124                 // Audit validation
1125                 AuditValidationUtils.deleteEcompConsumerAuditFailure(DELETE_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
1126                                 sdncAdminUserDetails, ActionStatus.ECOMP_USER_NOT_FOUND, consumerDataDefinition.getConsumerName());
1127
1128         }
1129
1130         @Test
1131         public void deleteEcompCredentialsUserNameIsNull() throws Exception {
1132                 DbUtils.deleteFromEsDbByPattern("_all");
1133                 consumerDataDefinition.setConsumerName(null);
1134                 RestResponse deleteConsumerRest = ConsumerRestUtils.deleteConsumer(consumerDataDefinition,
1135                                 sdncAdminUserDetails);
1136                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
1137                                 deleteConsumerRest.getErrorCode().intValue());
1138                 // Audit validation
1139                 AuditValidationUtils.deleteEcompConsumerAuditFailure(DELETE_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
1140                                 sdncAdminUserDetails, ActionStatus.ECOMP_USER_NOT_FOUND, consumerDataDefinition.getConsumerName());
1141         }
1142
1143         @Test
1144         public void deleteEcompCredentialsUserNameMaxLength() throws Exception {
1145                 DbUtils.deleteFromEsDbByPattern("_all");
1146                 consumerDataDefinition.setConsumerName(
1147                                 "_BCD-.abcdqwertyuiopasdfghjklzxcvbnmqw1234567890poiutrewasdfghjklqwertyuiopzaiutrewasdfg34567890poiutrewasdfghjklqwertyuiopzaiutrewasdfg34567890pf34567890poiutrewasdfghjklqwertyuiopzaiutrewasdfgghjklqwertyuiopzaiutrewasdfghjklqwertyuiopzasxcdferf123456.--"); // SVC4528
1148                 RestResponse deleteConsumerRest = ConsumerRestUtils.deleteConsumer(consumerDataDefinition,
1149                                 sdncAdminUserDetails);
1150                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
1151                                 deleteConsumerRest.getErrorCode().intValue());
1152                 // Audit validation
1153                 AuditValidationUtils.deleteEcompConsumerAuditFailure(DELETE_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
1154                                 sdncAdminUserDetails, ActionStatus.ECOMP_USER_NOT_FOUND, consumerDataDefinition.getConsumerName());
1155         }
1156
1157         @Test
1158         public void deleteEcompCredentialsUserNameExceedMaxLength() throws Exception {
1159                 DbUtils.deleteFromEsDbByPattern("_all");
1160                 consumerDataDefinition.setConsumerName(
1161                                 "_XXXBCD-.abcdqwertyuiopasdfghjklzxcvbnmqw1234567890poiutrewasdfghjklqwertyuiopzaiutrewasdfg34567890poiutrewasdfghjklqwertyuiopzaiutrewasdfg34567890pf34567890poiutrewasdfghjklqwertyuiopzaiutrewasdfgghjklqwertyuiopzaiutrewasdfghjklqwertyuiopzasxcdferf123456.--"); // SVC4528
1162                 RestResponse deleteConsumerRest = ConsumerRestUtils.deleteConsumer(consumerDataDefinition,
1163                                 sdncAdminUserDetails);
1164                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
1165                                 deleteConsumerRest.getErrorCode().intValue());
1166                 // Audit validation
1167                 AuditValidationUtils.deleteEcompConsumerAuditFailure(DELETE_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
1168                                 sdncAdminUserDetails, ActionStatus.ECOMP_USER_NOT_FOUND, consumerDataDefinition.getConsumerName());
1169         }
1170
1171         @Test
1172         public void deleteEcompCredentialsHttpCspUserIdHeaderIsMissing() throws Exception {
1173                 DbUtils.deleteFromEsDbByPattern("_all");
1174                 RestResponse createConsumerRest = ConsumerRestUtils.deleteConsumerHttpCspAtuUidIsMissing(consumerDataDefinition,
1175                                 sdncAdminUserDetails);
1176                 assertEquals("Check response code after create Consumer", STATUS_CODE_MISSING_INFORMATION,
1177                                 createConsumerRest.getErrorCode().intValue());
1178                 // Audit validation
1179                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_INFORMATION.name());
1180                 ExpectedEcomConsumerAudit expectedEcomConsumerAuditJavaObject = new ExpectedEcomConsumerAudit();
1181                 expectedEcomConsumerAuditJavaObject.setAction(DELETE_ECOMP_USER_CREDENTIALS);
1182                 expectedEcomConsumerAuditJavaObject.setEcomUser(consumerDataDefinition.getConsumerName());
1183                 expectedEcomConsumerAuditJavaObject.setStatus(errorInfo.getCode().toString());
1184                 expectedEcomConsumerAuditJavaObject.setDesc(errorInfo.getAuditDesc());
1185                 expectedEcomConsumerAuditJavaObject.setModifier("");
1186                 AuditValidationUtils.validateEcompConsumerAudit(expectedEcomConsumerAuditJavaObject,
1187                                 DELETE_ECOMP_USER_CREDENTIALS);
1188         }
1189
1190         @Test
1191         public void deleteEcompCredentialsNameIsUpperCase() throws Exception {
1192                 consumerDataDefinition.setConsumerName("benny");
1193                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
1194                                 sdncAdminUserDetails);
1195                 assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
1196                                 createConsumerRest.getErrorCode().intValue());
1197                 // Get Consumer
1198                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
1199                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
1200                                 getConsumerRest.getErrorCode().intValue());
1201                 // Delete consumer
1202                 DbUtils.deleteFromEsDbByPattern("_all");
1203                 consumerDataDefinition.setConsumerName("BENNY");
1204                 RestResponse deleteConsumerRest = ConsumerRestUtils.deleteConsumer(consumerDataDefinition,
1205                                 sdncAdminUserDetails);
1206                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
1207                                 deleteConsumerRest.getErrorCode().intValue());
1208                 // Audit validation
1209                 AuditValidationUtils.deleteEcompConsumerAuditFailure(DELETE_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
1210                                 sdncAdminUserDetails, ActionStatus.ECOMP_USER_NOT_FOUND, consumerDataDefinition.getConsumerName());
1211                 // Get Consumer to verify that consumer user was not deleted
1212                 consumerDataDefinition.setConsumerName("benny");
1213                 getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
1214                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
1215                                 getConsumerRest.getErrorCode().intValue());
1216         }
1217
1218         @Test
1219         public void getEcompCredentialsMethodGet() throws Exception {
1220                 // Create Consumer
1221                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
1222                                 sdncAdminUserDetails);
1223                 assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
1224                                 createConsumerRest.getErrorCode().intValue());
1225                 // parse updated response to javaObject
1226                 ConsumerDataDefinition getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(createConsumerRest);
1227                 // Validate actual consumerData to returned from response
1228                 ConsumerRestUtils.validateConsumerReqVsResp(consumerDataDefinition, getConsumerDataObject);
1229                 DbUtils.deleteFromEsDbByPattern("_all");
1230                 // Get Consumer
1231                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
1232                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
1233                                 getConsumerRest.getErrorCode().intValue());
1234                 getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(getConsumerRest);
1235                 ConsumerRestUtils.validateConsumerReqVsResp(consumerDataDefinition, getConsumerDataObject);
1236                 // Audit validation
1237                 AuditValidationUtils.ecompConsumerAuditSuccess(GET_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
1238                                 sdncAdminUserDetails, STATUS_CODE_SUCCESS_DELETE_GET);
1239                 // Delete consumer
1240                 ConsumerRestUtils.deleteConsumer(consumerDataDefinition, sdncAdminUserDetails);
1241         }
1242
1243         @Test
1244         public void getEcompUserAlreayDeleted() throws Exception {
1245                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
1246                                 sdncAdminUserDetails);
1247                 assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
1248                                 createConsumerRest.getErrorCode().intValue());
1249                 // Get Consumer
1250                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
1251                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
1252                                 getConsumerRest.getErrorCode().intValue());
1253                 // Delete ECOMP consumer
1254                 RestResponse deleteConsumerRest = ConsumerRestUtils.deleteConsumer(consumerDataDefinition,
1255                                 sdncAdminUserDetails);
1256                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS_DELETE_GET,
1257                                 deleteConsumerRest.getErrorCode().intValue());
1258                 DbUtils.deleteFromEsDbByPattern("_all");
1259                 // Try to get ECOMP consumer already deleted
1260                 getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
1261                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
1262                                 getConsumerRest.getErrorCode().intValue());
1263                 // Audit validation
1264                 AuditValidationUtils.deleteEcompConsumerAuditFailure(GET_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
1265                                 sdncAdminUserDetails, ActionStatus.ECOMP_USER_NOT_FOUND, consumerDataDefinition.getConsumerName());
1266         }
1267
1268         @Test
1269         public void getEcompUserByTester() throws Exception {
1270                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
1271                                 sdncAdminUserDetails);
1272                 assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
1273                                 createConsumerRest.getErrorCode().intValue());
1274                 // Get Consumer by Tester user
1275                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncTesterUserDetails);
1276                 assertEquals("Check response code after get Consumer", STATUS_CODE_RESTRICTED_OPERATION,
1277                                 getConsumerRest.getErrorCode().intValue());
1278                 // Audit validation
1279                 AuditValidationUtils.deleteEcompConsumerAuditFailure(GET_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
1280                                 sdncTesterUserDetails, ActionStatus.RESTRICTED_OPERATION);
1281                 // Get Consumer by Admin
1282                 getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
1283                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
1284                                 getConsumerRest.getErrorCode().intValue());
1285                 ConsumerRestUtils.deleteConsumer(consumerDataDefinition, sdncAdminUserDetails);
1286         }
1287
1288         @Test
1289         public void getEcompUserByOps() throws Exception {
1290                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
1291                                 sdncAdminUserDetails);
1292                 assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
1293                                 createConsumerRest.getErrorCode().intValue());
1294                 // Get Consumer by Ops user
1295                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncOpsUserDetails);
1296                 assertEquals("Check response code after get Consumer", STATUS_CODE_RESTRICTED_OPERATION,
1297                                 getConsumerRest.getErrorCode().intValue());
1298                 // Audit validation
1299                 AuditValidationUtils.deleteEcompConsumerAuditFailure(GET_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
1300                                 sdncOpsUserDetails, ActionStatus.RESTRICTED_OPERATION);
1301                 // Get Consumer by Admin
1302                 getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
1303                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
1304                                 getConsumerRest.getErrorCode().intValue());
1305                 ConsumerRestUtils.deleteConsumer(consumerDataDefinition, sdncAdminUserDetails);
1306         }
1307
1308         @Test
1309         public void getEcompUserByGovernor() throws Exception {
1310                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
1311                                 sdncAdminUserDetails);
1312                 assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
1313                                 createConsumerRest.getErrorCode().intValue());
1314                 // Get Consumer by Ops user
1315                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncGovernorUserDetails);
1316                 assertEquals("Check response code after get Consumer", STATUS_CODE_RESTRICTED_OPERATION,
1317                                 getConsumerRest.getErrorCode().intValue());
1318                 // Audit validation
1319                 AuditValidationUtils.deleteEcompConsumerAuditFailure(GET_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
1320                                 sdncGovernorUserDetails, ActionStatus.RESTRICTED_OPERATION);
1321                 // Get Consumer by Admin
1322                 getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
1323                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
1324                                 getConsumerRest.getErrorCode().intValue());
1325                 ConsumerRestUtils.deleteConsumer(consumerDataDefinition, sdncAdminUserDetails);
1326         }
1327
1328         @Test
1329         public void getEcompUserByDesigner() throws Exception {
1330                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
1331                                 sdncAdminUserDetails);
1332                 assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
1333                                 createConsumerRest.getErrorCode().intValue());
1334                 // Get Consumer by Designer user
1335                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncDesignerUserDetails);
1336                 assertEquals("Check response code after get Consumer", STATUS_CODE_RESTRICTED_OPERATION,
1337                                 getConsumerRest.getErrorCode().intValue());
1338                 // Audit validation
1339                 AuditValidationUtils.deleteEcompConsumerAuditFailure(GET_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
1340                                 sdncDesignerUserDetails, ActionStatus.RESTRICTED_OPERATION);
1341                 // Get Consumer by Admin
1342                 getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
1343                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
1344                                 getConsumerRest.getErrorCode().intValue());
1345                 ConsumerRestUtils.deleteConsumer(consumerDataDefinition, sdncAdminUserDetails);
1346         }
1347
1348         @Test
1349         public void getEcompUserByNoExistingIUser() throws Exception {
1350                 User noSdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1351                 noSdncUserDetails.setRole("blabla");
1352                 noSdncUserDetails.setUserId("bt750h");
1353                 // Get Consumer
1354                 DbUtils.deleteFromEsDbByPattern("_all");
1355                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, noSdncUserDetails);
1356                 assertEquals("Check response code after get Consumer", STATUS_CODE_RESTRICTED_ACCESS,
1357                                 getConsumerRest.getErrorCode().intValue());
1358                 // Audit validation
1359                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_ACCESS.name());
1360                 ExpectedEcomConsumerAudit expectedEcomConsumerAuditJavaObject = new ExpectedEcomConsumerAudit();
1361                 expectedEcomConsumerAuditJavaObject.setAction(GET_ECOMP_USER_CREDENTIALS);
1362                 expectedEcomConsumerAuditJavaObject.setEcomUser(consumerDataDefinition.getConsumerName());
1363                 expectedEcomConsumerAuditJavaObject.setStatus(errorInfo.getCode().toString());
1364                 expectedEcomConsumerAuditJavaObject.setDesc(errorInfo.getAuditDesc(""));
1365                 expectedEcomConsumerAuditJavaObject.setModifier("(" + noSdncUserDetails.getUserId() + ")");
1366                 AuditValidationUtils.validateEcompConsumerAudit(expectedEcomConsumerAuditJavaObject,
1367                                 GET_ECOMP_USER_CREDENTIALS);
1368         }
1369
1370         @Test
1371         public void getEcompCredentialsUserDoesNotExist() throws Exception {
1372                 DbUtils.deleteFromEsDbByPattern("_all");
1373                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
1374                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
1375                                 getConsumerRest.getErrorCode().intValue());
1376                 // Audit validation
1377                 AuditValidationUtils.deleteEcompConsumerAuditFailure(GET_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
1378                                 sdncAdminUserDetails, ActionStatus.ECOMP_USER_NOT_FOUND, consumerDataDefinition.getConsumerName());
1379
1380         }
1381
1382         @Test
1383         public void getEcompCredentialsUserNameIsNull() throws Exception {
1384                 DbUtils.deleteFromEsDbByPattern("_all");
1385                 consumerDataDefinition.setConsumerName(null);
1386                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
1387                 assertEquals("Check response code after get Consumer", STATUS_CODE_NOT_FOUND,
1388                                 getConsumerRest.getErrorCode().intValue());
1389                 // Audit validation
1390                 AuditValidationUtils.deleteEcompConsumerAuditFailure(GET_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
1391                                 sdncAdminUserDetails, ActionStatus.ECOMP_USER_NOT_FOUND, consumerDataDefinition.getConsumerName());
1392         }
1393
1394         @Test
1395         public void getEcompCredentialsUserNameMaxLength() throws Exception {
1396                 consumerDataDefinition.setConsumerName(
1397                                 "_ABCD-.abcdqwertyuiopasdfghjklzxcvbnmqw1234567890poiutrewasdfghjklqwertyuiopzaiutrewasdfg34567890poiutrewasdfghjklqwertyuiopzaiutrewasdfg34567890pf34567890poiutrewasdfghjklqwertyuiopzaiutrewasdfgghjklqwertyuiopzaiutrewasdfghjklqwertyuiopzasxcdferf123456.-"); // SVC4528
1398                 RestResponse createConsumerRest = ConsumerRestUtils.createConsumer(consumerDataDefinition,
1399                                 sdncAdminUserDetails);
1400                 assertEquals("Check response code after create Consumer", STATUS_CODE_SUCSESS_CREATED,
1401                                 createConsumerRest.getErrorCode().intValue());
1402                 // parse updated response to javaObject
1403                 ConsumerDataDefinition getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(createConsumerRest);
1404                 // Validate actual consumerData to returned from response
1405                 ConsumerRestUtils.validateConsumerReqVsResp(consumerDataDefinition, getConsumerDataObject);
1406                 // Get Consumer
1407                 DbUtils.deleteFromEsDbByPattern("_all");
1408                 RestResponse getConsumerRest = ConsumerRestUtils.getConsumer(consumerDataDefinition, sdncAdminUserDetails);
1409                 assertEquals("Check response code after get Consumer", STATUS_CODE_SUCCESS,
1410                                 getConsumerRest.getErrorCode().intValue());
1411                 getConsumerDataObject = ConsumerRestUtils.parseComsumerResp(getConsumerRest);
1412                 ConsumerRestUtils.validateConsumerReqVsResp(consumerDataDefinition, getConsumerDataObject);
1413                 // Audit validation
1414                 AuditValidationUtils.ecompConsumerAuditSuccess(GET_ECOMP_USER_CREDENTIALS, consumerDataDefinition,
1415                                 sdncAdminUserDetails, STATUS_CODE_SUCCESS_DELETE_GET);
1416                 // Delete consumer
1417                 ConsumerRestUtils.deleteConsumer(consumerDataDefinition, sdncAdminUserDetails);
1418         }
1419 }