gerrit.onap Code Review - sdc.git/blob

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