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