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