test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/user/CreateUserApiTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.ci.tests.execute.user;
  22
  23 import static org.testng.AssertJUnit.assertEquals;
  24 import static org.testng.AssertJUnit.assertNotNull;
  25
  26 import java.io.IOException;
  27
  28 import org.junit.Rule;
  29 import org.junit.rules.TestName;
  30 import org.openecomp.sdc.be.dao.api.ActionStatus;
  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.ExpectedUserCRUDAudit;
  36 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  37 import org.openecomp.sdc.ci.tests.users.UserResponseMessageEnum;
  38 import org.openecomp.sdc.ci.tests.utils.DbUtils;
  39 import org.openecomp.sdc.ci.tests.utils.general.Convertor;
  40 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  41 import org.openecomp.sdc.ci.tests.utils.rest.UserRestUtils;
  42 import org.openecomp.sdc.ci.tests.utils.validation.AuditValidationUtils;
  43 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  44 import org.openecomp.sdc.ci.tests.utils.validation.UserValidationUtils;
  45 import org.testng.AssertJUnit;
  46 import org.testng.annotations.AfterMethod;
  47 import org.testng.annotations.BeforeMethod;
  48 import org.testng.annotations.Test;
  49
  50 public class CreateUserApiTest extends ComponentBaseTest {
  51
  52         protected User sdncAdminUser;
  53         protected User sdncDesignerUser;
  54         protected User sdncGovernorUser;
  55         protected User sdncTesterUser;
  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         public static final int STATUS_CODE_NOT_FOUND = 404;
  65         public static final int STATUS_CODE_RESTRICTED_OPERATION = 409;
  66         public static final int USER_ALREADY_EXIST = 409;
  67         public static final int INVALID_ROLE = 400;
  68
  69         @Rule
  70         public static TestName name = new TestName();
  71
  72         public CreateUserApiTest() {
  73                 super(name, CreateUserApiTest.class.getName());
  74         }
  75
  76         @BeforeMethod
  77         public void init() {
  78                 sdncAdminUser = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
  79                 sdncDesignerUser = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
  80                 sdncGovernorUser = ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR);
  81                 sdncTesterUser = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
  82
  83         }
  84
  85         // Story : REST API to provision new user (POST) - US429379
  86         // must parameters: UserId and Email
  87
  88         // **********************************************************201***************************************************
  89         // create user with full parameter set(UserID, First Name, Last Name, Email,
  90         // Role = "DESIGNER", Creator details)
  91         // expected 201 Created
  92         @Test
  93         public void createUser() throws Exception {
  94
  95                 // user initialization
  96                 String httpCspUserId = "km2000";
  97                 String userFirstName = "Kot";
  98                 String userLastName = "Matroskin";
  99                 String email = "km2000@intl.sdc.com";
 100                 String role = "ADMIN";
 101                 User sdncUserDetails = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 102                 String addUser = "AddUser";
 103                 UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
 104                 DbUtils.cleanAllAudits();
 105                 RestResponse createUserResponse = UserRestUtils.createUser(sdncUserDetails, sdncAdminUser);
 106
 107                 AssertJUnit.assertNotNull("check response object is not null after create user", createUserResponse);
 108                 AssertJUnit.assertNotNull("check error code exists in response after create user",
 109                                 createUserResponse.getErrorCode());
 110                 AssertJUnit.assertEquals("Check response code after create user", 201,
 111                                 createUserResponse.getErrorCode().intValue());
 112
 113                 UserValidationUtils.validateUserDetailsOnResponse(sdncUserDetails, createUserResponse.getResponse());
 114
 115                 ExpectedUserCRUDAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(addUser,
 116                                 sdncAdminUser, ActionStatus.CREATED, sdncUserDetails, null);
 117                 AuditValidationUtils.validateAddUserAudit(constructFieldsForAuditValidation, addUser);
 118                 RestResponse getUserResponse = UserRestUtils.getUser(sdncUserDetails, sdncAdminUser);
 119                 UserValidationUtils.validateUserDetailsOnResponse(sdncUserDetails, getUserResponse.getResponse());
 120         }
 121
 122         protected static final String ADD_USER = "AddUser";
 123
 124         private User mechIdUser = new User();
 125         private User emptyUser = new User();
 126         private static final User adminUser = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 127
 128         @AfterMethod
 129         public void setup() throws IOException {
 130                 UserRestUtils.deactivateUser(mechIdUser, adminUser);
 131         }
 132
 133         // create default user(UserID, Email, Creator details)
 134         // expected: role = DESIGNER, first and last name = null, 201 Created
 135         @Test
 136         public void createDefaultUser() throws Exception {
 137                 // user initialization
 138                 String httpCspUserId = "km2000";
 139                 String userFirstName = null;
 140                 String userLastName = null;
 141                 String email = null;
 142                 String role = null;
 143                 User sdncUserDetails = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 144
 145                 deleteUserAndAudit(sdncUserDetails);
 146                 RestResponse createUserResponse = UserRestUtils.createUser(sdncUserDetails, sdncAdminUser);
 147
 148                 assertNotNull("check response object is not null after create user", createUserResponse);
 149                 assertNotNull("check error code exists in response after create user", createUserResponse.getErrorCode());
 150                 assertEquals("Check response code after create user", 201, createUserResponse.getErrorCode().intValue());
 151
 152                 UserValidationUtils.validateUserDetailsOnResponse(sdncUserDetails, createUserResponse.getResponse());
 153                 UserValidationUtils.validateAddUserAuditMessage(sdncUserDetails, sdncAdminUser, "201",
 154                                 UserResponseMessageEnum.SUCCESS_MESSAGE.getValue(),
 155                                 UserValidationUtils.getAddUserAuditMessage("AddUser"));
 156                 RestResponse getUserResponse = UserRestUtils.getUser(sdncUserDetails, sdncAdminUser);
 157                 UserValidationUtils.validateUserDetailsOnResponse(sdncUserDetails, getUserResponse.getResponse());
 158
 159         }
 160
 161         // create user with one optional parameter first name (UserID, Email, First
 162         // Name, Creator details)
 163         // expected: role = DESIGNER, last name = null, 201 Created
 164         @Test
 165         public void createUserFirstName() throws Exception {
 166                 // user initialization
 167                 String httpCspUserId = "km2000";
 168                 String userFirstName = "Kot";
 169                 String userLastName = null;
 170                 String email = null;
 171                 String role = null;
 172                 User sdncUserDetails = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 173
 174                 deleteUserAndAudit(sdncUserDetails);
 175                 RestResponse createUserResponse = UserRestUtils.createUser(sdncUserDetails, sdncAdminUser);
 176
 177                 assertNotNull("check response object is not null after create user", createUserResponse);
 178                 assertNotNull("check error code exists in response after create user", createUserResponse.getErrorCode());
 179                 assertEquals("Check response code after create user", 201, createUserResponse.getErrorCode().intValue());
 180
 181                 UserValidationUtils.validateUserDetailsOnResponse(sdncUserDetails, createUserResponse.getResponse());
 182                 UserValidationUtils.validateAddUserAuditMessage(sdncUserDetails, sdncAdminUser, "201",
 183                                 UserResponseMessageEnum.SUCCESS_MESSAGE.getValue(),
 184                                 UserValidationUtils.getAddUserAuditMessage("AddUser"));
 185                 RestResponse getUserResponse = UserRestUtils.getUser(sdncUserDetails, sdncAdminUser);
 186                 UserValidationUtils.validateUserDetailsOnResponse(sdncUserDetails, getUserResponse.getResponse());
 187         }
 188
 189         @Test
 190         public void createDeleteOpsUser() throws Exception {
 191
 192                 String httpCspUserId = "oo2000";
 193                 String userFirstName = "ops";
 194                 String userLastName = "opsLast";
 195                 String email = "ops@intl.sdc.com";
 196                 String role = "OPS";
 197                 User sdncUserDetails = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 198
 199                 deleteUserAndAudit(sdncUserDetails);
 200                 RestResponse createUserResponse = UserRestUtils.createUser(sdncUserDetails, sdncAdminUser);
 201
 202                 assertNotNull("check response object is not null after create user", createUserResponse);
 203                 assertNotNull("check error code exists in response after create user", createUserResponse.getErrorCode());
 204                 assertEquals("Check response code after create user", 201, createUserResponse.getErrorCode().intValue());
 205
 206                 UserValidationUtils.validateUserDetailsOnResponse(sdncUserDetails, createUserResponse.getResponse());
 207                 UserValidationUtils.validateAddUserAuditMessage(sdncUserDetails, sdncAdminUser, "201",
 208                                 UserResponseMessageEnum.SUCCESS_MESSAGE.getValue(),
 209                                 UserValidationUtils.getAddUserAuditMessage("AddUser"));
 210                 RestResponse getUserResponse = UserRestUtils.getUser(sdncUserDetails, sdncAdminUser);
 211                 UserValidationUtils.validateUserDetailsOnResponse(sdncUserDetails, getUserResponse.getResponse());
 212
 213                 UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
 214                 RestResponse getDeletedUserResponse = UserRestUtils.getUser(sdncUserDetails, sdncAdminUser);
 215                 assertEquals("Check response code after delete user", 404, getDeletedUserResponse.getErrorCode().intValue());
 216
 217         }
 218
 219         @Test
 220         public void createDeleteGOVERNORUser() throws Exception {
 221
 222                 String httpCspUserId = "gg2000";
 223                 String userFirstName = "gov";
 224                 String userLastName = "govLast";
 225                 String email = "gov@intl.sdc.com";
 226                 String role = "GOVERNOR";
 227                 User sdncUserDetails = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 228
 229                 deleteUserAndAudit(sdncUserDetails);
 230                 RestResponse createUserResponse = UserRestUtils.createUser(sdncUserDetails, sdncAdminUser);
 231                 assertNotNull("check response object is not null after create user", createUserResponse);
 232                 assertNotNull("check error code exists in response after create user", createUserResponse.getErrorCode());
 233                 assertEquals("Check response code after create user", 201, createUserResponse.getErrorCode().intValue());
 234
 235                 UserValidationUtils.validateUserDetailsOnResponse(sdncUserDetails, createUserResponse.getResponse());
 236                 UserValidationUtils.validateAddUserAuditMessage(sdncUserDetails, sdncAdminUser, "201",
 237                                 UserResponseMessageEnum.SUCCESS_MESSAGE.getValue(),
 238                                 UserValidationUtils.getAddUserAuditMessage("AddUser"));
 239                 RestResponse getUserResponse = UserRestUtils.getUser(sdncUserDetails, sdncAdminUser);
 240                 UserValidationUtils.validateUserDetailsOnResponse(sdncUserDetails, getUserResponse.getResponse());
 241
 242                 UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
 243                 RestResponse getDeletedUserResponse = UserRestUtils.getUser(sdncUserDetails, sdncAdminUser);
 244                 assertEquals("Check response code after delete user", 404, getDeletedUserResponse.getErrorCode().intValue());
 245
 246         }
 247
 248         // Benny
 249         // Admin Create OPS user
 250         @Test
 251         public void createOpsUser() throws Exception {
 252                 DbUtils.cleanAllAudits();
 253
 254                 String httpCspUserId = "aa1000";
 255                 String userFirstName = "Benny";
 256                 String userLastName = "Tal";
 257                 String email = "optBenny@intl.sdc.com";
 258                 String role = "OPS";
 259                 User expectedOpsUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 260                 deleteUserAndAudit(expectedOpsUser);
 261                 RestResponse createUserResponse = UserRestUtils.createUser(expectedOpsUser, sdncAdminUser);
 262                 assertNotNull("check response object is not null after create user", createUserResponse);
 263                 assertNotNull("check error code exists in response after create user", createUserResponse.getErrorCode());
 264                 assertEquals("Check response code after create user", 201, createUserResponse.getErrorCode().intValue());
 265                 UserValidationUtils.validateUserDetailsOnResponse(expectedOpsUser, createUserResponse.getResponse());
 266                 deleteAndCheckUserResponse(expectedOpsUser, 200);
 267
 268         }
 269
 270         // Admin Create GOVERNOR user
 271         @Test
 272         public void createGovernorUser() throws Exception {
 273                 DbUtils.cleanAllAudits();
 274
 275                 String httpCspUserId = "aa1000";
 276                 String userFirstName = "Benny";
 277                 String userLastName = "Tal";
 278                 String email = "optBenny@intl.sdc.com";
 279                 String role = "GOVERNOR";
 280                 User expectedUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 281                 deleteUserAndAudit(expectedUser);
 282                 RestResponse createUserResponse = UserRestUtils.createUser(expectedUser, sdncAdminUser);
 283                 assertNotNull("check response object is not null after create user", createUserResponse);
 284                 assertNotNull("check error code exists in response after create user", createUserResponse.getErrorCode());
 285                 assertEquals("Check response code after create user", 201, createUserResponse.getErrorCode().intValue());
 286                 UserValidationUtils.validateUserDetailsOnResponse(expectedUser, createUserResponse.getResponse());
 287                 RestResponse getUserResponse = UserRestUtils.getUser(expectedUser, sdncAdminUser);
 288                 UserValidationUtils.validateUserDetailsOnResponse(expectedUser, getUserResponse.getResponse());
 289                 // Delete OPS user
 290                 RestResponse deleteOpsUser = UserRestUtils.deleteUser(expectedUser, sdncAdminUser, true);
 291                 assertNotNull("check response object is not null after deleting user", deleteOpsUser);
 292                 assertEquals("Check response code after deleting user", 200, deleteOpsUser.getErrorCode().intValue());
 293
 294         }
 295
 296         // Admin Update user role from OPS to GOVERNOR
 297         @Test
 298         public void updateOpsUserRole() throws Exception {
 299                 DbUtils.cleanAllAudits();
 300
 301                 String httpCspUserId = "ab1000";
 302                 String userFirstName = "Benny";
 303                 String userLastName = "Tal";
 304                 String email = "optBenny@intl.sdc.com";
 305                 String role = "OPS";
 306                 String updatedRole = "GOVERNOR";
 307                 User opsUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 308                 User governerUser = new User(userFirstName, userLastName, httpCspUserId, email, updatedRole, null);
 309                 // UserRestUtils.deleteUser(opsUser, sdncAdminUser, true);
 310                 // UserRestUtils.deleteUser(UserUpdateRole, sdncAdminUser);
 311                 RestResponse createUserResponse = UserRestUtils.createUser(opsUser, sdncAdminUser);
 312                 assertNotNull("check response object is not null after create user", createUserResponse);
 313                 assertNotNull("check error code exists in response after create user", createUserResponse.getErrorCode());
 314                 assertEquals("Check response code after create user", 201, createUserResponse.getErrorCode().intValue());
 315                 UserValidationUtils.validateUserDetailsOnResponse(opsUser, createUserResponse.getResponse());
 316
 317                 // opsUser.setRole(updatedRole);
 318                 User newRoleUser = new User();
 319                 newRoleUser.setRole(updatedRole);
 320                 // update user role from OPS to GOVERNOR
 321                 RestResponse updateUserRoleResponse = UserRestUtils.updateUserRole(newRoleUser, sdncAdminUser,
 322                                 opsUser.getUserId());
 323                 assertNotNull("check response object is not null after updating user", updateUserRoleResponse);
 324                 assertNotNull("check error code exists in response after updating user", updateUserRoleResponse.getErrorCode());
 325                 assertEquals("Check response code after updating user", 200, updateUserRoleResponse.getErrorCode().intValue());
 326
 327                 RestResponse getUpdatedRoleUserResponse = UserRestUtils.getUser(governerUser, sdncAdminUser);
 328                 UserValidationUtils.validateUserDetailsOnResponse(governerUser, getUpdatedRoleUserResponse.getResponse());
 329                 // Delete OPS user
 330                 RestResponse deleteOpsUser = UserRestUtils.deleteUser(opsUser, sdncAdminUser, true);
 331                 assertNotNull("check response object is not null after deleting user", deleteOpsUser);
 332                 assertEquals("Check response code after deleting user", 200, deleteOpsUser.getErrorCode().intValue());
 333
 334         }
 335
 336         // Designer Create OPS user -409 Response Restricted operation
 337         @Test
 338         public void createOpsUserByDesigner() throws Exception {
 339                 DbUtils.cleanAllAudits();
 340
 341                 String httpCspUserId = "aa1122";
 342                 String userFirstName = "Benny";
 343                 String userLastName = "Tal";
 344                 String email = "optBenny@intl.sdc.com";
 345                 String role = "OPS";
 346                 User expectedOpsUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 347                 deleteUserAndAudit(expectedOpsUser);
 348                 RestResponse createUserResponse = UserRestUtils.createUser(expectedOpsUser, sdncDesignerUser);
 349                 assertNotNull("check response object is not null after create user", createUserResponse);
 350                 assertNotNull("check error code exists in response after create user", createUserResponse.getErrorCode());
 351                 assertEquals("Check response code after create user", 409, createUserResponse.getErrorCode().intValue());
 352                 assertEquals("Check response code after create user", "Conflict", createUserResponse.getResponseMessage());
 353         }
 354
 355         // Tester Create OPS user -409 Response Restricted operation
 356         @Test
 357         public void createOpsUserByTester() throws Exception {
 358                 DbUtils.cleanAllAudits();
 359
 360                 String httpCspUserId = "aa1122";
 361                 String userFirstName = "Benny";
 362                 String userLastName = "Tal";
 363                 String email = "optBenny@intl.sdc.com";
 364                 String role = "OPS";
 365                 User expectedOpsUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 366                 deleteUserAndAudit(expectedOpsUser);
 367                 RestResponse createUserResponse = UserRestUtils.createUser(expectedOpsUser, sdncTesterUser);
 368                 assertNotNull("check response object is not null after create user", createUserResponse);
 369                 assertNotNull("check error code exists in response after create user", createUserResponse.getErrorCode());
 370                 assertEquals("Check response code after create user", 409, createUserResponse.getErrorCode().intValue());
 371                 assertEquals("Check response code after create user", "Conflict", createUserResponse.getResponseMessage());
 372         }
 373
 374         // Designer Try Update OPS user role to GOVERNOR - Response 409
 375         @Test
 376         public void updateOpsUserRolebyDesigner() throws Exception {
 377                 DbUtils.cleanAllAudits();
 378
 379                 String httpCspUserId = "bt751e";
 380                 String userFirstName = "Benny";
 381                 String userLastName = "Tal";
 382                 String email = "optBenny@intl.sdc.com";
 383                 String role = "OPS";
 384                 String updatedRole = "GOVERNOR";
 385                 User opsUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 386                 User governerUser = new User(userFirstName, userLastName, httpCspUserId, email, updatedRole, null);
 387                 // Admin create user with OPS role
 388                 RestResponse createUserResponse = UserRestUtils.createUser(opsUser, sdncAdminUser);
 389                 assertNotNull("check response object is not null after create user", createUserResponse);
 390                 assertNotNull("check error code exists in response after create user", createUserResponse.getErrorCode());
 391                 assertEquals("Check response code after create user", 201, createUserResponse.getErrorCode().intValue());
 392                 UserValidationUtils.validateUserDetailsOnResponse(opsUser, createUserResponse.getResponse());
 393                 User newRoleUser = new User();
 394                 newRoleUser.setRole(updatedRole);
 395                 // Designer user try to update user role from OPS to GOVERNOR
 396                 RestResponse updateUserRoleResponse = UserRestUtils.updateUserRole(newRoleUser, sdncDesignerUser,
 397                                 opsUser.getUserId());
 398                 assertNotNull("check response object is not null after updating user", updateUserRoleResponse);
 399                 assertNotNull("check error code exists in response after updating user", updateUserRoleResponse.getErrorCode());
 400                 assertEquals("Check response code after updating user", 409, updateUserRoleResponse.getErrorCode().intValue());
 401                 assertEquals("Check response code after updating user", "Conflict",
 402                                 updateUserRoleResponse.getResponseMessage());
 403                 // Delete OPS user
 404                 RestResponse deleteOpsUser = UserRestUtils.deleteUser(opsUser, sdncAdminUser, true);
 405                 assertNotNull("check response object is not null after deleting  user", deleteOpsUser);
 406                 assertEquals("Check response code after deleting  user", 200, deleteOpsUser.getErrorCode().intValue());
 407
 408         }
 409
 410         // Tester Try Update OPS user role to GOVERNOR - Response 409
 411         @Test
 412         public void updateOpsUserRolebyTester() throws Exception {
 413                 DbUtils.cleanAllAudits();
 414
 415                 String httpCspUserId = "bt751w";
 416                 String userFirstName = "Benny";
 417                 String userLastName = "Tal";
 418                 String email = "optBenny@intl.sdc.com";
 419                 String role = "OPS";
 420                 String updatedRole = "GOVERNOR";
 421                 User opsUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 422                 User governerUser = new User(userFirstName, userLastName, httpCspUserId, email, updatedRole, null);
 423                 // Admin create user with OPS role
 424                 RestResponse createUserResponse = UserRestUtils.createUser(opsUser, sdncAdminUser);
 425                 assertNotNull("check response object is not null after create user", createUserResponse);
 426                 assertNotNull("check error code exists in response after create user", createUserResponse.getErrorCode());
 427                 assertEquals("Check response code after create user", 201, createUserResponse.getErrorCode().intValue());
 428                 UserValidationUtils.validateUserDetailsOnResponse(opsUser, createUserResponse.getResponse());
 429                 User newRoleUser = new User();
 430                 newRoleUser.setRole(updatedRole);
 431                 // Designer user try to update user role from OPS to GOVERNOR
 432                 RestResponse updateUserRoleResponse = UserRestUtils.updateUserRole(newRoleUser, sdncTesterUser,
 433                                 opsUser.getUserId());
 434                 assertNotNull("check response object is not null after updating user", updateUserRoleResponse);
 435                 assertNotNull("check error code exists in response after updating user", updateUserRoleResponse.getErrorCode());
 436                 assertEquals("Check response code after updating user", 409, updateUserRoleResponse.getErrorCode().intValue());
 437                 assertEquals("Check response code after updating user", "Conflict",
 438                                 updateUserRoleResponse.getResponseMessage());
 439                 // Delete OPS user
 440                 RestResponse deleteOpsUser = UserRestUtils.deleteUser(opsUser, sdncAdminUser, true);
 441                 assertNotNull("check response object is not null after deleting user", deleteOpsUser);
 442                 assertEquals("Check response code after deleting user", 200, deleteOpsUser.getErrorCode().intValue());
 443
 444         }
 445
 446         // Admin Update user role from OPS to Designer
 447         @Test
 448         public void updateOpsUserRoleFromOpsToDesigner() throws Exception {
 449                 DbUtils.cleanAllAudits();
 450
 451                 String httpCspUserId = "ab1000";
 452                 String userFirstName = "Benny";
 453                 String userLastName = "Tal";
 454                 String email = "optBenny@intl.sdc.com";
 455                 String role = "OPS";
 456                 String updatedRole = "DESIGNER";
 457                 User opsUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 458                 User designerUser = new User(userFirstName, userLastName, httpCspUserId, email, updatedRole, null);
 459                 // UserRestUtils.deleteUser(opsUser, sdncAdminUser, true);
 460                 // UserRestUtils.deleteUser(UserUpdateRole, sdncAdminUser);
 461                 RestResponse createUserResponse = UserRestUtils.createUser(opsUser, sdncAdminUser);
 462                 assertNotNull("check response object is not null after create user", createUserResponse);
 463                 assertNotNull("check error code exists in response after create user", createUserResponse.getErrorCode());
 464                 assertEquals("Check response code after create user", 201, createUserResponse.getErrorCode().intValue());
 465                 UserValidationUtils.validateUserDetailsOnResponse(opsUser, createUserResponse.getResponse());
 466
 467                 // opsUser.setRole(updatedRole);
 468                 User newRoleUser = new User();
 469                 newRoleUser.setRole(updatedRole);
 470                 // update user role from OPS to GOVERNOR
 471                 RestResponse updateUserRoleResponse = UserRestUtils.updateUserRole(newRoleUser, sdncAdminUser,
 472                                 opsUser.getUserId());
 473                 assertNotNull("check response object is not null after updating user", updateUserRoleResponse);
 474                 assertNotNull("check error code exists in response after updating user", updateUserRoleResponse.getErrorCode());
 475                 assertEquals("Check response code after updating user", 200, updateUserRoleResponse.getErrorCode().intValue());
 476
 477                 RestResponse getUpdatedRoleUserResponse = UserRestUtils.getUser(designerUser, sdncAdminUser);
 478                 UserValidationUtils.validateUserDetailsOnResponse(designerUser, getUpdatedRoleUserResponse.getResponse());
 479                 // Delete OPS user
 480                 RestResponse deleteOpsUser = UserRestUtils.deleteUser(opsUser, sdncAdminUser, true);
 481                 assertNotNull("check response object is not null after deleting user", deleteOpsUser);
 482                 assertEquals("Check response code after deleting user", 200, deleteOpsUser.getErrorCode().intValue());
 483
 484         }
 485
 486         // Admin Update user role from OPS to TESTER
 487         @Test
 488         public void updateOpsUserRoleFromOpsToTester() throws Exception {
 489                 DbUtils.cleanAllAudits();
 490
 491                 String httpCspUserId = "ac1001";
 492                 String userFirstName = "Benny";
 493                 String userLastName = "Tal";
 494                 String email = "optBenny@intl.sdc.com";
 495                 String role = "OPS";
 496                 String updatedRole = "TESTER";
 497                 User opsUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 498                 User testerUser = new User(userFirstName, userLastName, httpCspUserId, email, updatedRole, null);
 499                 // UserRestUtils.deleteUser(opsUser, sdncAdminUser, true);
 500                 // UserRestUtils.deleteUser(UserUpdateRole, sdncAdminUser);
 501                 RestResponse createUserResponse = UserRestUtils.createUser(opsUser, sdncAdminUser);
 502                 assertNotNull("check response object is not null after create user", createUserResponse);
 503                 assertNotNull("check error code exists in response after create user", createUserResponse.getErrorCode());
 504                 assertEquals("Check response code after create user", 201, createUserResponse.getErrorCode().intValue());
 505                 UserValidationUtils.validateUserDetailsOnResponse(opsUser, createUserResponse.getResponse());
 506
 507                 // opsUser.setRole(updatedRole);
 508                 User newRoleUser = new User();
 509                 newRoleUser.setRole(updatedRole);
 510                 // update user role from OPS to GOVERNOR
 511                 RestResponse updateUserRoleResponse = UserRestUtils.updateUserRole(newRoleUser, sdncAdminUser,
 512                                 opsUser.getUserId());
 513                 assertNotNull("check response object is not null after updating user", updateUserRoleResponse);
 514                 assertNotNull("check error code exists in response after updating user", updateUserRoleResponse.getErrorCode());
 515                 assertEquals("Check response code after updating user", 200, updateUserRoleResponse.getErrorCode().intValue());
 516
 517                 RestResponse getUpdatedRoleUserResponse = UserRestUtils.getUser(testerUser, sdncAdminUser);
 518                 UserValidationUtils.validateUserDetailsOnResponse(testerUser, getUpdatedRoleUserResponse.getResponse());
 519                 // Delete OPS user
 520                 RestResponse deleteOpsUser = UserRestUtils.deleteUser(opsUser, sdncAdminUser, true);
 521                 assertNotNull("check response object is not null after deleting user", deleteOpsUser);
 522                 assertEquals("Check response code after deleting user", 200, deleteOpsUser.getErrorCode().intValue());
 523
 524         }
 525
 526         // Tester try to Update user role from OPS to GOVERNOR - Response 409
 527         // Conflict
 528         @Test
 529         public void updateOpsUserRoleByTester() throws Exception {
 530                 DbUtils.cleanAllAudits();
 531
 532                 String httpCspUserId = "ad1001";
 533                 String userFirstName = "Benny";
 534                 String userLastName = "Tal";
 535                 String email = "optBenny@intl.sdc.com";
 536                 String role = "OPS";
 537                 String updatedRole = "GOVERNOR";
 538                 User opsUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 539                 User governerUser = new User(userFirstName, userLastName, httpCspUserId, email, updatedRole, null);
 540                 // UserRestUtils.deleteUser(opsUser, sdncAdminUser, true);
 541                 // UserRestUtils.deleteUser(UserUpdateRole, sdncAdminUser);
 542                 // Create user by Admin
 543                 RestResponse createUserResponse = UserRestUtils.createUser(opsUser, sdncAdminUser);
 544                 assertNotNull("check response object is not null after create user", createUserResponse);
 545                 assertNotNull("check error code exists in response after create user", createUserResponse.getErrorCode());
 546                 assertEquals("Check response code after create user", 201, createUserResponse.getErrorCode().intValue());
 547                 UserValidationUtils.validateUserDetailsOnResponse(opsUser, createUserResponse.getResponse());
 548                 User newRoleUser = new User();
 549                 newRoleUser.setRole(updatedRole);
 550                 // update user role from OPS to GOVERNOR by Tester
 551                 RestResponse updateUserRoleResponse = UserRestUtils.updateUserRole(newRoleUser, sdncTesterUser,
 552                                 opsUser.getUserId());
 553                 assertNotNull("check response object is not null after updating user", updateUserRoleResponse);
 554                 assertNotNull("check error code exists in response after updating user", updateUserRoleResponse.getErrorCode());
 555                 assertEquals("Check response code after updating user", 409, updateUserRoleResponse.getErrorCode().intValue());
 556                 assertEquals("Check response code after updating user", "Conflict",
 557                                 updateUserRoleResponse.getResponseMessage());
 558
 559                 // Delete OPS user
 560                 RestResponse deleteOpsUser = UserRestUtils.deleteUser(opsUser, sdncAdminUser, true);
 561                 assertNotNull("check response object is not null after deleting user", deleteOpsUser);
 562                 assertEquals("Check response code after deleting user", 200, deleteOpsUser.getErrorCode().intValue());
 563
 564         }
 565
 566         // Designer try to Update user role from OPS to GOVERNOR - Response 409
 567         // Conflict
 568         @Test
 569         public void updateOpsUserRoleByDesigner() throws Exception {
 570                 DbUtils.cleanAllAudits();
 571
 572                 String httpCspUserId = "ad1001";
 573                 String userFirstName = "Benny";
 574                 String userLastName = "Tal";
 575                 String email = "optBenny@intl.sdc.com";
 576                 String role = "OPS";
 577                 String updatedRole = "GOVERNOR";
 578                 User opsUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 579                 // User governerUser = new User(userFirstName,
 580                 // userLastName,httpCspUserId, email, updatedRole);
 581                 // UserRestUtils.deleteUser(opsUser, sdncAdminUser, true);
 582                 // UserRestUtils.deleteUser(UserUpdateRole, sdncAdminUser);
 583                 // Create user by Admin
 584                 RestResponse createUserResponse = UserRestUtils.createUser(opsUser, sdncAdminUser);
 585                 assertNotNull("check response object is not null after create user", createUserResponse);
 586                 assertNotNull("check error code exists in response after create user", createUserResponse.getErrorCode());
 587                 assertEquals("Check response code after create user", 201, createUserResponse.getErrorCode().intValue());
 588                 UserValidationUtils.validateUserDetailsOnResponse(opsUser, createUserResponse.getResponse());
 589                 User newRoleUser = new User();
 590                 newRoleUser.setRole(updatedRole);
 591                 // update user role from OPS to GOVERNOR by Tester
 592                 RestResponse updateUserRoleResponse = UserRestUtils.updateUserRole(newRoleUser, sdncDesignerUser,
 593                                 opsUser.getUserId());
 594                 assertNotNull("check response object is not null after updating user", updateUserRoleResponse);
 595                 assertNotNull("check error code exists in response after updating user", updateUserRoleResponse.getErrorCode());
 596                 assertEquals("Check response code after updating user", 409, updateUserRoleResponse.getErrorCode().intValue());
 597                 assertEquals("Check response code after updating user", "Conflict",
 598                                 updateUserRoleResponse.getResponseMessage());
 599
 600                 // Delete OPS user
 601                 RestResponse deleteOpsUser = UserRestUtils.deleteUser(opsUser, sdncAdminUser, true);
 602                 assertNotNull("check response object is not null after deleting user", deleteOpsUser);
 603                 assertEquals("Check response code after deleting user", 200, deleteOpsUser.getErrorCode().intValue());
 604
 605         }
 606
 607         // Admin Create OPS user - user already exist
 608         @Test
 609         public void createOpsUserAlreadyExist() throws Exception {
 610                 DbUtils.cleanAllAudits();
 611
 612                 String httpCspUserId = "af1000";
 613                 String userFirstName = "Benny";
 614                 String userLastName = "Tal";
 615                 String email = "optBenny@intl.sdc.com";
 616                 String role = "OPS";
 617                 User expectedOpsUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 618                 deleteUserAndAudit(expectedOpsUser);
 619                 RestResponse createUserResponse = UserRestUtils.createUser(expectedOpsUser, sdncAdminUser);
 620                 assertNotNull("check response object is not null after create user", createUserResponse);
 621                 assertNotNull("check error code exists in response after create user", createUserResponse.getErrorCode());
 622                 assertEquals("Check response code after create user", 201, createUserResponse.getErrorCode().intValue());
 623                 UserValidationUtils.validateUserDetailsOnResponse(expectedOpsUser, createUserResponse.getResponse());
 624                 // Create user that already exists
 625                 RestResponse createUserAgainResponse = UserRestUtils.createUser(expectedOpsUser, sdncAdminUser);
 626                 assertNotNull("check response object is not null after create user", createUserAgainResponse);
 627                 assertNotNull("check error code exists in response after create user", createUserAgainResponse.getErrorCode());
 628                 assertEquals("Check response code after create user", 409, createUserAgainResponse.getErrorCode().intValue());
 629                 // Delete OPS user
 630                 RestResponse deleteOpsUser = UserRestUtils.deleteUser(expectedOpsUser, sdncAdminUser, true);
 631                 assertNotNull("check response object is not null after deleting user", deleteOpsUser);
 632                 assertEquals("Check response code after deleting  user", 200, deleteOpsUser.getErrorCode().intValue());
 633
 634         }
 635
 636         // Admin Update user role from OPS to GOVERNOR - user already has GOVERNOR
 637         // role
 638         @Test
 639         public void updateRoleToSameRole() throws Exception {
 640                 DbUtils.cleanAllAudits();
 641
 642                 String httpCspUserId = "ag1000";
 643                 String userFirstName = "Benny";
 644                 String userLastName = "Tal";
 645                 String email = "optBenny@intl.sdc.com";
 646                 String role = "GOVERNOR";
 647                 String updatedRole = "GOVERNOR";
 648                 User opsUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 649                 User governerUser = new User(userFirstName, userLastName, httpCspUserId, email, updatedRole, null);
 650                 RestResponse createUserResponse = UserRestUtils.createUser(opsUser, sdncAdminUser);
 651                 assertNotNull("check response object is not null after create user", createUserResponse);
 652                 assertNotNull("check error code exists in response after create user", createUserResponse.getErrorCode());
 653                 assertEquals("Check response code after create user", 201, createUserResponse.getErrorCode().intValue());
 654                 UserValidationUtils.validateUserDetailsOnResponse(opsUser, createUserResponse.getResponse());
 655                 // opsUser.setRole(updatedRole);
 656                 User newRoleUser = new User();
 657                 newRoleUser.setRole(updatedRole);
 658                 // update user role from GOVERNOR to GOVERNOR
 659                 RestResponse updateUserRoleResponse = UserRestUtils.updateUserRole(newRoleUser, sdncAdminUser,
 660                                 opsUser.getUserId());
 661                 assertNotNull("check response object is not null after updating user", updateUserRoleResponse);
 662                 assertNotNull("check error code exists in response after updating user", updateUserRoleResponse.getErrorCode());
 663                 assertEquals("Check response code after updating user", 200, updateUserRoleResponse.getErrorCode().intValue());
 664
 665                 RestResponse getUpdatedRoleUserResponse = UserRestUtils.getUser(governerUser, sdncAdminUser);
 666                 UserValidationUtils.validateUserDetailsOnResponse(governerUser, getUpdatedRoleUserResponse.getResponse());
 667                 // Delete OPS user
 668                 RestResponse deleteOpsUser = UserRestUtils.deleteUser(opsUser, sdncAdminUser, true);
 669                 assertNotNull("check response object is not null after deleting user", deleteOpsUser);
 670                 assertEquals("Check response code after deleting user", 200, deleteOpsUser.getErrorCode().intValue());
 671
 672         }
 673
 674         // Admin Update user role from Tester to GOVERNOR - 200 response
 675
 676         // Admin Update user role from Designer to GOVERNOR - 200 response
 677         @Test
 678         public void updateUserRoleDesignerToGovernor() throws Exception {
 679                 DbUtils.cleanAllAudits();
 680                 String httpCspUserId = "ah1000";
 681                 String userFirstName = "Benny";
 682                 String userLastName = "Tal";
 683                 String email = "optBenny@intl.sdc.com";
 684                 String role = "DESIGNER";
 685                 String updatedRole = "GOVERNOR";
 686                 User designerUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 687                 User governerUser = new User(userFirstName, userLastName, httpCspUserId, email, updatedRole, null);
 688                 // create user
 689                 RestResponse createUserResponse = UserRestUtils.createUser(designerUser, sdncAdminUser);
 690                 assertNotNull("check response object is not null after create user", createUserResponse);
 691                 assertNotNull("check error code exists in response after create user", createUserResponse.getErrorCode());
 692                 assertEquals("Check response code after create user", 201, createUserResponse.getErrorCode().intValue());
 693                 UserValidationUtils.validateUserDetailsOnResponse(designerUser, createUserResponse.getResponse());
 694                 // opsUser.setRole(updatedRole);
 695                 User newRoleUser = new User();
 696                 newRoleUser.setRole(updatedRole);
 697                 // update user role from TESTER to GOVERNOR
 698                 RestResponse updateUserRoleResponse = UserRestUtils.updateUserRole(newRoleUser, sdncAdminUser,
 699                                 designerUser.getUserId());
 700                 assertNotNull("check response object is not null after updating user", updateUserRoleResponse);
 701                 assertNotNull("check error code exists in response after updating user", updateUserRoleResponse.getErrorCode());
 702                 assertEquals("Check response code after updating user", 200, updateUserRoleResponse.getErrorCode().intValue());
 703                 // Update user role
 704                 RestResponse getUpdatedRoleUserResponse = UserRestUtils.getUser(governerUser, sdncAdminUser);
 705                 UserValidationUtils.validateUserDetailsOnResponse(governerUser, getUpdatedRoleUserResponse.getResponse());
 706                 // Delete OPS user
 707                 RestResponse deleteOpsUser = UserRestUtils.deleteUser(designerUser, sdncAdminUser, true);
 708                 assertNotNull("check response object is not null after deleting user", deleteOpsUser);
 709                 assertEquals("Check response code after deleting user", 200, deleteOpsUser.getErrorCode().intValue());
 710
 711         }
 712
 713         // Admin Update deactivated user role - response 404 (user not found)
 714         @Test
 715         public void updateRoleToDeactivatedUser() throws Exception {
 716                 DbUtils.cleanAllAudits();
 717                 String httpCspUserId = "aj1001";
 718                 String userFirstName = "Benny";
 719                 String userLastName = "Tal";
 720                 String email = "optBenny@intl.sdc.com";
 721                 String role = "DESIGNER";
 722                 String updatedRole = "GOVERNOR";
 723                 User designerUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 724                 User governerUser = new User(userFirstName, userLastName, httpCspUserId, email, updatedRole, null);
 725                 // create user
 726                 RestResponse createUserResponse = UserRestUtils.createUser(designerUser, sdncAdminUser);
 727                 assertNotNull("check response object is not null after create user", createUserResponse);
 728                 assertNotNull("check error code exists in response after create user", createUserResponse.getErrorCode());
 729                 assertEquals("Check response code after create user", 201, createUserResponse.getErrorCode().intValue());
 730                 UserValidationUtils.validateUserDetailsOnResponse(designerUser, createUserResponse.getResponse());
 731                 deleteAndCheckUserResponse(designerUser, 200);
 732                 User newRoleUser = new User();
 733                 newRoleUser.setRole(updatedRole);
 734                 // update user role - user deActivted
 735                 RestResponse updateUserRoleResponse = UserRestUtils.updateUserRole(newRoleUser, sdncAdminUser,
 736                                 designerUser.getUserId());
 737                 assertNotNull("check response object is not null after updating user", updateUserRoleResponse);
 738                 assertNotNull("check error code exists in response after updating user", updateUserRoleResponse.getErrorCode());
 739                 assertEquals("Check response code after create user", 404, updateUserRoleResponse.getErrorCode().intValue());
 740         }
 741
 742         // Admin Update user role, user does not exist in DB - response 404 (user
 743         // not found)
 744         @Test
 745         public void updateRoleForNonExistingUser() throws Exception {
 746                 DbUtils.cleanAllAudits();
 747                 String httpCspUserId = "aj1001";
 748                 String userFirstName = "Benny";
 749                 String userLastName = "Tal";
 750                 String email = "optBenny@intl.sdc.com";
 751                 String role = "DESIGNER";
 752                 String updatedRole = "GOVERNOR";
 753                 User designerUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 754                 // User governerUser = new User(userFirstName,
 755                 // userLastName,httpCspUserId, email, updatedRole);
 756                 User newRoleUser = new User();
 757                 newRoleUser.setRole(updatedRole);
 758                 // update user role - user deActivted
 759                 RestResponse updateUserRoleResponse = UserRestUtils.updateUserRole(newRoleUser, sdncAdminUser,
 760                                 designerUser.getUserId());
 761                 assertNotNull("check response object is not null after updating user", updateUserRoleResponse);
 762                 assertNotNull("check error code exists in response after updating user", updateUserRoleResponse.getErrorCode());
 763                 assertEquals("Check response code after updating user", 404, updateUserRoleResponse.getErrorCode().intValue());
 764
 765         }
 766
 767         // Admin Update user role from GOVERNOR to TESTER
 768         @Test
 769         public void updateRoleFromGovernorToTester() throws Exception {
 770                 DbUtils.cleanAllAudits();
 771
 772                 String httpCspUserId = "ak1000";
 773                 String userFirstName = "Benny";
 774                 String userLastName = "Tal";
 775                 String email = "optBenny@intl.sdc.com";
 776                 String role = "GOVERNOR";
 777                 String updatedRole = "TESTER";
 778                 User governorUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 779                 User testerUser = new User(userFirstName, userLastName, httpCspUserId, email, updatedRole, null);
 780                 // UserRestUtils.deleteUser(opsUser, sdncAdminUser, true);
 781                 // UserRestUtils.deleteUser(UserUpdateRole, sdncAdminUser);
 782                 RestResponse createUserResponse = UserRestUtils.createUser(governorUser, sdncAdminUser);
 783                 assertNotNull("check response object is not null after create user", createUserResponse);
 784                 assertNotNull("check error code exists in response after create user", createUserResponse.getErrorCode());
 785                 assertEquals("Check response code after create user", 201, createUserResponse.getErrorCode().intValue());
 786                 UserValidationUtils.validateUserDetailsOnResponse(governorUser, createUserResponse.getResponse());
 787
 788                 // opsUser.setRole(updatedRole);
 789                 User newRoleUser = new User();
 790                 newRoleUser.setRole(updatedRole);
 791                 // update user role from OPS to GOVERNOR
 792                 RestResponse updateUserRoleResponse = UserRestUtils.updateUserRole(newRoleUser, sdncAdminUser,
 793                                 governorUser.getUserId());
 794                 assertNotNull("check response object is not null after updating user", updateUserRoleResponse);
 795                 assertNotNull("check error code exists in response after updating user", updateUserRoleResponse.getErrorCode());
 796                 assertEquals("Check response code after updating user", 200, updateUserRoleResponse.getErrorCode().intValue());
 797
 798                 RestResponse getUpdatedRoleUserResponse = UserRestUtils.getUser(testerUser, sdncAdminUser);
 799                 UserValidationUtils.validateUserDetailsOnResponse(testerUser, getUpdatedRoleUserResponse.getResponse());
 800                 // Delete OPS user
 801                 RestResponse deleteOpsUser = UserRestUtils.deleteUser(governorUser, sdncAdminUser, true);
 802                 assertNotNull("check response object is not null after deleting user", deleteOpsUser);
 803                 assertEquals("Check response code after deleting user", 200, deleteOpsUser.getErrorCode().intValue());
 804
 805         }
 806
 807         // Admin Update user role from GOVERNOR to DESIGNER
 808         @Test
 809         public void updateRoleFromGovernorToDesigner() throws Exception {
 810                 DbUtils.cleanAllAudits();
 811
 812                 String httpCspUserId = "ak1000";
 813                 String userFirstName = "Benny";
 814                 String userLastName = "Tal";
 815                 String email = "optBenny@intl.sdc.com";
 816                 String role = "GOVERNOR";
 817                 String updatedRole = "DESIGNER";
 818                 User governorUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 819                 User designerUser = new User(userFirstName, userLastName, httpCspUserId, email, updatedRole, null);
 820                 // UserRestUtils.deleteUser(opsUser, sdncAdminUser, true);
 821                 // UserRestUtils.deleteUser(UserUpdateRole, sdncAdminUser);
 822                 RestResponse createUserResponse = UserRestUtils.createUser(governorUser, sdncAdminUser);
 823                 assertNotNull("check response object is not null after create user", createUserResponse);
 824                 assertNotNull("check error code exists in response after create user", createUserResponse.getErrorCode());
 825                 assertEquals("Check response code after create user", 201, createUserResponse.getErrorCode().intValue());
 826                 UserValidationUtils.validateUserDetailsOnResponse(governorUser, createUserResponse.getResponse());
 827
 828                 // opsUser.setRole(updatedRole);
 829                 User newRoleUser = new User();
 830                 newRoleUser.setRole(updatedRole);
 831                 // update user role from OPS to GOVERNOR
 832                 RestResponse updateUserRoleResponse = UserRestUtils.updateUserRole(newRoleUser, sdncAdminUser,
 833                                 governorUser.getUserId());
 834                 assertNotNull("check response object is not null after updating user", updateUserRoleResponse);
 835                 assertNotNull("check error code exists in response after updating user", updateUserRoleResponse.getErrorCode());
 836                 assertEquals("Check response code after updating user", 200, updateUserRoleResponse.getErrorCode().intValue());
 837
 838                 RestResponse getUpdatedRoleUserResponse = UserRestUtils.getUser(designerUser, sdncAdminUser);
 839                 UserValidationUtils.validateUserDetailsOnResponse(designerUser, getUpdatedRoleUserResponse.getResponse());
 840                 // Delete OPS user
 841                 RestResponse deleteOpsUser = UserRestUtils.deleteUser(governorUser, sdncAdminUser, true);
 842                 assertNotNull("check response object is not null after deleting user", deleteOpsUser);
 843                 assertEquals("Check response code after deleting user", 200, deleteOpsUser.getErrorCode().intValue());
 844
 845         }
 846
 847         // Admin Update user role from GOVERNOR to OPS
 848         @Test
 849         public void updateRoleFromGovernorToOps() throws Exception {
 850                 DbUtils.cleanAllAudits();
 851
 852                 String httpCspUserId = "ak1000";
 853                 String userFirstName = "Benny";
 854                 String userLastName = "Tal";
 855                 String email = "optBenny@intl.sdc.com";
 856                 String role = "GOVERNOR";
 857                 String updatedRole = "OPS";
 858                 User governorUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 859                 User opsUser = new User(userFirstName, userLastName, httpCspUserId, email, updatedRole, null);
 860                 // UserRestUtils.deleteUser(opsUser, sdncAdminUser, true);
 861                 // UserRestUtils.deleteUser(UserUpdateRole, sdncAdminUser);
 862                 RestResponse createUserResponse = UserRestUtils.createUser(governorUser, sdncAdminUser);
 863                 assertNotNull("check response object is not null after create user", createUserResponse);
 864                 assertNotNull("check error code exists in response after create user", createUserResponse.getErrorCode());
 865                 assertEquals("Check response code after create user", 201, createUserResponse.getErrorCode().intValue());
 866                 UserValidationUtils.validateUserDetailsOnResponse(governorUser, createUserResponse.getResponse());
 867                 // opsUser.setRole(updatedRole);
 868                 User newRoleUser = new User();
 869                 newRoleUser.setRole(updatedRole);
 870                 // update user role from OPS to GOVERNOR
 871                 RestResponse updateUserRoleResponse = UserRestUtils.updateUserRole(newRoleUser, sdncAdminUser,
 872                                 governorUser.getUserId());
 873                 assertNotNull("check response object is not null after updating user", updateUserRoleResponse);
 874                 assertNotNull("check error code exists in response after updating user", updateUserRoleResponse.getErrorCode());
 875                 assertEquals("Check response code after updating user", 200, updateUserRoleResponse.getErrorCode().intValue());
 876
 877                 RestResponse getUpdatedRoleUserResponse = UserRestUtils.getUser(opsUser, sdncAdminUser);
 878                 UserValidationUtils.validateUserDetailsOnResponse(opsUser, getUpdatedRoleUserResponse.getResponse());
 879                 // Delete OPS user
 880                 deleteAndCheckUserResponse(governorUser, 200);
 881
 882         }
 883
 884         private void deleteAndCheckUserResponse(User userDetailes, int expectedResponseCode) throws IOException {
 885                 RestResponse deleteUser = UserRestUtils.deleteUser(sdncGovernorUser, sdncAdminUser, true);
 886                 assertNotNull("check response object is not null after deleting user", deleteUser);
 887                 assertEquals("Check response code after deleting user", expectedResponseCode,
 888                                 deleteUser.getErrorCode().intValue());
 889         }
 890
 891         // Admin Update user role from GOVERNOR to ADMIN
 892         @Test
 893         public void updateRoleFromGovernorToAdmin() throws Exception {
 894                 DbUtils.cleanAllAudits();
 895
 896                 String httpCspUserId = "ak1000";
 897                 String userFirstName = "Benny";
 898                 String userLastName = "Tal";
 899                 String email = "optBenny@intl.sdc.com";
 900                 String role = "GOVERNOR";
 901                 String updatedRole = "ADMIN";
 902                 User governorUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 903                 User adminUser = new User(userFirstName, userLastName, httpCspUserId, email, updatedRole, null);
 904                 // UserRestUtils.deleteUser(opsUser, sdncAdminUser, true);
 905                 // UserRestUtils.deleteUser(UserUpdateRole, sdncAdminUser);
 906                 RestResponse createUserResponse = UserRestUtils.createUser(governorUser, sdncAdminUser);
 907                 assertNotNull("check response object is not null after create user", createUserResponse);
 908                 assertNotNull("check error code exists in response after create user", createUserResponse.getErrorCode());
 909                 assertEquals("Check response code after create user", 201, createUserResponse.getErrorCode().intValue());
 910                 UserValidationUtils.validateUserDetailsOnResponse(governorUser, createUserResponse.getResponse());
 911                 // opsUser.setRole(updatedRole);
 912                 User newRoleUser = new User();
 913                 newRoleUser.setRole(updatedRole);
 914                 // update user role from OPS to GOVERNOR
 915                 RestResponse updateUserRoleResponse = UserRestUtils.updateUserRole(newRoleUser, sdncAdminUser,
 916                                 governorUser.getUserId());
 917                 assertNotNull("check response object is not null after updating user", updateUserRoleResponse);
 918                 assertNotNull("check error code exists in response after updating user", updateUserRoleResponse.getErrorCode());
 919                 assertEquals("Check response code after updating user", 200, updateUserRoleResponse.getErrorCode().intValue());
 920
 921                 RestResponse getUpdatedRoleUserResponse = UserRestUtils.getUser(adminUser, sdncAdminUser);
 922                 UserValidationUtils.validateUserDetailsOnResponse(adminUser, getUpdatedRoleUserResponse.getResponse());
 923                 // Delete OPS user
 924                 RestResponse deleteOpsUser = UserRestUtils.deleteUser(governorUser, sdncAdminUser, true);
 925                 assertNotNull("check response object is not null after deleting user", deleteOpsUser);
 926                 assertEquals("Check response code after deleting user", 200, deleteOpsUser.getErrorCode().intValue());
 927
 928         }
 929
 930         // Admin Update user role to non existing role - Response 400 Bad Request
 931         @Test
 932         public void updateRoleToNonExistingRole() throws Exception {
 933                 DbUtils.cleanAllAudits();
 934
 935                 String httpCspUserId = "al1001";
 936                 String userFirstName = "Benny";
 937                 String userLastName = "Tal";
 938                 String email = "optBenny@intl.sdc.com";
 939                 String role = "GOVERNOR";
 940                 String updatedRole = "VVVVVVV";
 941                 User governorUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 942                 User newUser = new User(userFirstName, userLastName, httpCspUserId, email, updatedRole, null);
 943                 // UserRestUtils.deleteUser(opsUser, sdncAdminUser, true);
 944                 // UserRestUtils.deleteUser(UserUpdateRole, sdncAdminUser);
 945                 RestResponse createUserResponse = UserRestUtils.createUser(governorUser, sdncAdminUser);
 946                 assertNotNull("check response object is not null after create user", createUserResponse);
 947                 assertNotNull("check error code exists in response after create user", createUserResponse.getErrorCode());
 948                 assertEquals("Check response code after create user", 201, createUserResponse.getErrorCode().intValue());
 949                 UserValidationUtils.validateUserDetailsOnResponse(governorUser, createUserResponse.getResponse());
 950                 // opsUser.setRole(updatedRole);
 951                 User newRoleUser = new User();
 952                 newRoleUser.setRole(updatedRole);
 953                 // update user role from OPS to GOVERNOR
 954                 RestResponse updateUserRoleResponse = UserRestUtils.updateUserRole(newRoleUser, sdncAdminUser,
 955                                 governorUser.getUserId());
 956                 assertNotNull("check response object is not null after updating user", updateUserRoleResponse);
 957                 assertNotNull("check error code exists in response after updating user", updateUserRoleResponse.getErrorCode());
 958                 assertEquals("Check response code after updating user", 400, updateUserRoleResponse.getErrorCode().intValue());
 959                 assertEquals("Check response code after updating user", "Bad Request",
 960                                 updateUserRoleResponse.getResponseMessage());
 961
 962                 // RestResponse getUpdatedRoleUserResponse =
 963                 // UserRestUtils.getUser(adminUser,sdncAdminUser);
 964                 // UserValidationUtils.validateUserDetailsOnResponse(adminUser,getUpdatedRoleUserResponse.getResponse());
 965                 // Delete OPS user
 966                 RestResponse deleteOpsUser = UserRestUtils.deleteUser(governorUser, sdncAdminUser, true);
 967                 assertNotNull("check response object is not null after deleting user", deleteOpsUser);
 968                 assertEquals("Check response code after deleting user", 200, deleteOpsUser.getErrorCode().intValue());
 969
 970         }
 971
 972         // Admin Update user role to null - Response 400 Bad Request
 973         @Test
 974         public void updateRoleToNull() throws Exception {
 975                 DbUtils.cleanAllAudits();
 976
 977                 String httpCspUserId = "ax1001";
 978                 String userFirstName = "Benny";
 979                 String userLastName = "Tal";
 980                 String email = "optBenny@intl.sdc.com";
 981                 String role = "GOVERNOR";
 982                 String updatedRole = "";
 983                 User governorUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 984                 User newUser = new User(userFirstName, userLastName, httpCspUserId, email, updatedRole, null);
 985                 // UserRestUtils.deleteUser(opsUser, sdncAdminUser, true);
 986                 // UserRestUtils.deleteUser(UserUpdateRole, sdncAdminUser);
 987                 RestResponse createUserResponse = UserRestUtils.createUser(governorUser, sdncAdminUser);
 988                 assertNotNull("check response object is not null after create user", createUserResponse);
 989                 assertNotNull("check error code exists in response after create user", createUserResponse.getErrorCode());
 990                 assertEquals("Check response code after create user", 201, createUserResponse.getErrorCode().intValue());
 991                 UserValidationUtils.validateUserDetailsOnResponse(governorUser, createUserResponse.getResponse());
 992                 // opsUser.setRole(updatedRole);
 993                 User newRoleUser = new User();
 994                 newRoleUser.setRole(updatedRole);
 995                 // update user role
 996                 RestResponse updateUserRoleResponse = UserRestUtils.updateUserRole(newRoleUser, sdncAdminUser,
 997                                 governorUser.getUserId());
 998                 assertNotNull("check response object is not null after updating user", updateUserRoleResponse);
 999                 assertNotNull("check error code exists in response after updating user", updateUserRoleResponse.getErrorCode());
1000                 assertEquals("Check response code after updating user", 400, updateUserRoleResponse.getErrorCode().intValue());
1001                 assertEquals("Check response code after updating user", "Bad Request",
1002                                 updateUserRoleResponse.getResponseMessage());
1003                 // Delete user
1004                 RestResponse deleteOpsUser = UserRestUtils.deleteUser(governorUser, sdncAdminUser, true);
1005                 assertNotNull("check response object is not null after deleting user", deleteOpsUser);
1006                 assertEquals("Check response code after deleting user", 200, deleteOpsUser.getErrorCode().intValue());
1007
1008         }
1009
1010         // create user with one optional parameter last name (UserID, Email, Last
1011         // Name, Creator details)
1012         // expected: role = DESIGNER, first name = null, 201 Created
1013         // @Test
1014         // public void createUserLastName(){
1015         // // send POST create user request
1016         // // validate data on response
1017         // // check the audit message
1018         // }
1019         //
1020         // // create user with one optional parameter role name (UserID, Email, Role
1021         // = "TESTER", Creator details)
1022         // // expected: first and last name = null, 201 Created
1023         // @Test
1024         // public void createUserRoleName(){
1025         // // send POST create user request
1026         // // validate data on response
1027         // // check the audit message
1028         // }
1029         //
1030         // // create user with two optional parameters first name and role (UserID,
1031         // Email, First Name, Role = "ADMIN", Creator details)
1032         // // expected: last name = null, 201 Created
1033         // @Test
1034         // public void createUserFirstNameAndRole(){
1035         // // send POST create user request
1036         // // validate data on response
1037         // // check the audit message
1038         // }
1039         //
1040         // // create user with two optional parameters first and last name(UserID,
1041         // Email, First Name, Last name, Creator details)
1042         // // expected: role = DESIGNER, 201 Created
1043         // @Test
1044         // public void createUserFirstAndLastName(){
1045         // // send POST create user request
1046         // // validate data on response
1047         // // check the audit message
1048         // }
1049         //
1050         //
1051         //
1052         //
1053         //
1054         // //
1055         // **********************************************************Create*user*failed***************************************************
1056         //
1057         // //
1058         // **********************************************************403***************************************************
1059         // // create default user without creator details (UserID, Email)
1060         // // expected: 403 Forbidden, error message:"Error : Missing information"
1061         // @Test
1062         // public void createDefaultUserNonCreatorDetails(){
1063         // // send POST create user request
1064         // // validate data on response
1065         // // check the audit message
1066         // }
1067         //
1068         //
1069         // // create user with part of creator details (UserID, Email, First name,
1070         // Last Name, Role, Part of creator details)
1071         // // expected: 403 Forbidden, error message:"Error : Missing information"
1072         // @Test
1073         // public void createUserPartOfCreatorDetails(){
1074         // // send POST create user request
1075         // // validate data on response
1076         // // check the audit message
1077         // }
1078         //
1079         // // create user with full parameter set, non admin creator(UserID, First
1080         // Name, Last Name, Email, Role, Creator details)
1081         // // expected: 403 Forbidden, error message:
1082         // "Error : Restricted operation"
1083         // @Test
1084         // public void createUserNonAdminCreator(){
1085         // // send POST create user request
1086         // // validate data on response
1087         // // check the audit message
1088         // }
1089         //
1090         //
1091         // //
1092         // **********************************************************405***************************************************
1093         //
1094         // // create user with full parameter set by sending http PUT request
1095         // (UserID, First Name, Last Name, Email, Role, Creator details)
1096         // // expected: 405 not Allowed, error message:
1097         // "Error : Method not allowed"
1098         // @Test
1099         // public void createUserPutRequest(){
1100         // // send PUT create user request
1101         // // validate data on response
1102         // // check the audit message
1103         // }
1104         //
1105         //
1106         // // create default user by sending http PUT request (UserID, Email,
1107         // Creator details)
1108         // // expected: 405 not Allowed, error message:
1109         // "Error : Method not allowed"
1110         // @Test
1111         // public void createDefaultUserPutRequest(){
1112         // // send PUT create user request
1113         // // validate data on response
1114         // // check the audit message
1115         // }
1116         //
1117         //
1118         // // create user with full parameter set by sending http DELETE request
1119         // (UserID, First Name, Last Name, Email, Role, Creator details)
1120         // // expected: 405 not Allowed, error message:
1121         // "Error : Method not allowed"
1122         // @Test
1123         // public void createUserDeleteRequest(){
1124         // // send DELETE create user request
1125         // // validate data on response
1126         // // check the audit message
1127         // }
1128         //
1129         //
1130         // // create default user by sending http DELETE request (UserID, Email,
1131         // Creator details)
1132         // // expected: 405 not Allowed, error message:
1133         // "Error : Method not allowed"
1134         // @Test
1135         // public void createDefaultUserDeleteRequest(){
1136         // // send DELETE create user request
1137         // // validate data on response
1138         // // check the audit message
1139         // }
1140         //
1141         //
1142         // // create user with full parameter set by sending http GET request
1143         // (UserID, First Name, Last Name, Email, Role, Creator details)
1144         // // expected: 405 not Allowed, error message:
1145         // "Error : Method not allowed"
1146         // @Test
1147         // public void createUserGetRequest(){
1148         // // send GET create user request
1149         // // validate data on response
1150         // // check the audit message
1151         // }
1152         //
1153         //
1154         // // create default user by sending http GET request (UserID, Email,
1155         // Creator details)
1156         // // expected: 405 not Allowed, error message:
1157         // "Error : Method not allowed"
1158         // @Test
1159         // public void createDefaultUserGetRequest(){
1160         // // send GET create user request
1161         // // validate data on response
1162         // // check the audit message
1163         // }
1164         //
1165         //
1166         // //
1167         // **********************************************************409***************************************************
1168         //
1169         // // create the same user twice with full parameter set(UserID, First Name,
1170         // Last Name, Email, Role, Creator details)
1171         // // expected 409 Conflict, error message:
1172         // "Error : User with '%s' ID already exists", where: %s - USER_ID
1173         // @Test
1174         // public void createSameUserTwice(){
1175         // // send POST create user request
1176         // // validate data on response
1177         // // send POST create user request
1178         // // validate data on response
1179         // // check the audit message
1180         // }
1181         //
1182         // // create user twice, first full details (UserID, First Name, Last Name,
1183         // Email, Role, Creator details), second default user (UserID, Email, Role,
1184         // Creator details)
1185         // // expected 409 Conflict, error message:
1186         // "Error : User with '%s' ID already exists", where: %s - USER_ID
1187         // @Test
1188         // public void createFullThanDefaultUserTwice(){
1189         // // send POST create user request
1190         //
1191         // // validate data on response
1192         // // send POST create user request
1193         // // validate data on response
1194         // // check the audit message
1195         // }
1196         //
1197         // // create user twice, first default user (UserID, Email, Role, Creator
1198         // details), second full details (UserID, First Name, Last Name, Email,
1199         // Role, Creator details)
1200         // // expected 409 Conflict, error message:
1201         // "Error : User with '%s' ID already exists", where: %s - USER_ID
1202         // @Test
1203         // public void createDefaulThanFullUserTwice(){
1204         // // send POST create user request
1205         //
1206         // // validate data on response
1207         // // send POST create user request
1208         // // validate data on response
1209         // // check the audit message
1210         // }
1211         //
1212         //
1213         // //
1214         // **********************************************************400***************************************************
1215         // // create default user with invalid email address format(UserID, Email,
1216         // Creator details)
1217         // // expected: 400, error message:
1218         // "Error : Invalid Content . Invalid e-mail address '%s'", where %s -
1219         // email address
1220         // @Test
1221         // public void createDefaultUserInvalidEmailAddressFormat(){
1222         // // send GET create user request
1223         // // validate data on response
1224         // // check the audit message
1225         // }
1226         //
1227         // // create an user with invalid role type (UserID, Email,Role = "TESTER-1"
1228         // ,Creator details)
1229         // // expected: 400, error message:
1230         // "Error : Invalid Content . Invalid role '%s'", where %s - role type
1231         // @Test
1232         // public void createUserInvalidRoleType(){
1233         // // send GET create user request
1234         // // validate data on response
1235         // // check the audit message
1236         // }
1237         //
1238         // //
1239         // **********************************************************500***************************************************
1240         // // create default user when BE is down (UserID, Email, Creator details)
1241         // // expected: 500, error message:
1242         // "Error : Internal Server Error . Try later again."
1243         // @Test
1244         // public void createDefaultUserBeNoAccess(){
1245         // // send GET create user request
1246         // // validate data on response
1247         // // check the audit message
1248         // }
1249         //
1250
1251         // Benny US570551
1252
1253         @Test
1254         public void createProductManagerUser() throws Exception {
1255                 String httpCspUserId = "pm1000";
1256                 String userFirstName = "Prod";
1257                 String userLastName = "Man";
1258                 String email = "prodMan@intl.sdc.com";
1259                 String role = "PRODUCT_MANAGER";
1260                 User expectedProductManagerUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
1261                 UserRestUtils.deleteUser(expectedProductManagerUser, sdncAdminUser, true);
1262                 DbUtils.deleteFromEsDbByPattern("_all");
1263                 // create user
1264                 RestResponse createUserResponse = UserRestUtils.createUser(expectedProductManagerUser, sdncAdminUser);
1265                 assertEquals("Check response code after create Product-Manager user", STATUS_CODE_SUCSESS_CREATED,
1266                                 createUserResponse.getErrorCode().intValue());
1267                 UserValidationUtils.validateUserDetailsOnResponse(expectedProductManagerUser, createUserResponse.getResponse());
1268                 // Audit validation
1269                 UserValidationUtils.validateAddUserAuditMessage(expectedProductManagerUser, sdncAdminUser,
1270                                 Integer.toString(STATUS_CODE_SUCSESS_CREATED), UserResponseMessageEnum.SUCCESS_MESSAGE.getValue(),
1271                                 UserValidationUtils.getAddUserAuditMessage("AddUser"));
1272                 // get user and compare with expected
1273                 RestResponse getUserResponse = UserRestUtils.getUser(expectedProductManagerUser, sdncAdminUser);
1274                 UserValidationUtils.validateUserDetailsOnResponse(expectedProductManagerUser, getUserResponse.getResponse());
1275                 // Delete ProductManager user
1276                 RestResponse deleteProductManagerUser = UserRestUtils.deleteUser(expectedProductManagerUser, sdncAdminUser,
1277                                 true);
1278                 assertEquals("Check response code after deleting OPS user", STATUS_CODE_SUCCESS,
1279                                 deleteProductManagerUser.getErrorCode().intValue());
1280         }
1281
1282         @Test
1283         public void createProductStrategistUser() throws Exception {
1284                 String httpCspUserId = "pm1000";
1285                 String userFirstName = "Prod";
1286                 String userLastName = "Strategist";
1287                 String email = "prodStr@intl.sdc.com";
1288                 String role = "PRODUCT_STRATEGIST";
1289                 User expectedProductStrategistUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
1290                 UserRestUtils.deleteUser(expectedProductStrategistUser, sdncAdminUser, true);
1291                 DbUtils.deleteFromEsDbByPattern("_all");
1292                 // create user
1293                 RestResponse createUserResponse = UserRestUtils.createUser(expectedProductStrategistUser, sdncAdminUser);
1294                 assertEquals("Check response code after create Product-Manager user", STATUS_CODE_SUCSESS_CREATED,
1295                                 createUserResponse.getErrorCode().intValue());
1296                 UserValidationUtils.validateUserDetailsOnResponse(expectedProductStrategistUser,
1297                                 createUserResponse.getResponse());
1298                 // Audit validation
1299                 UserValidationUtils.validateAddUserAuditMessage(expectedProductStrategistUser, sdncAdminUser,
1300                                 Integer.toString(STATUS_CODE_SUCSESS_CREATED), UserResponseMessageEnum.SUCCESS_MESSAGE.getValue(),
1301                                 UserValidationUtils.getAddUserAuditMessage("AddUser"));
1302                 // get user and compare with expected
1303                 RestResponse getUserResponse = UserRestUtils.getUser(expectedProductStrategistUser, sdncAdminUser);
1304                 UserValidationUtils.validateUserDetailsOnResponse(expectedProductStrategistUser, getUserResponse.getResponse());
1305                 // Delete ProductStrategist user
1306                 RestResponse deleteProductStrategistUser = UserRestUtils.deleteUser(expectedProductStrategistUser,
1307                                 sdncAdminUser, true);
1308                 assertNotNull("Check response object is not null after deleting OPS user", deleteProductStrategistUser);
1309                 assertEquals("Check response code after deleting OPS user", 200,
1310                                 deleteProductStrategistUser.getErrorCode().intValue());
1311         }
1312
1313         @Test
1314         public void createProductStrategistUserByNonAdminUser() throws Exception {
1315                 String httpCspUserId = "pm1000";
1316                 String userFirstName = "Prod";
1317                 String userLastName = "Strategist";
1318                 String email = "prodStr@intl.sdc.com";
1319                 String role = "PRODUCT_STRATEGIST";
1320                 User expectedProductStrategistUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
1321                 UserRestUtils.deleteUser(expectedProductStrategistUser, sdncAdminUser, true);
1322                 DbUtils.deleteFromEsDbByPattern("_all");
1323                 // create user
1324                 RestResponse createUserResponse = UserRestUtils.createUser(expectedProductStrategistUser, sdncDesignerUser);
1325                 assertEquals("Check response code after create Product-Manager user", STATUS_CODE_RESTRICTED_OPERATION,
1326                                 createUserResponse.getErrorCode().intValue());
1327                 // Audit validation
1328                 expectedProductStrategistUser.setUserId("");
1329                 expectedProductStrategistUser.setFirstName(null);
1330                 expectedProductStrategistUser.setLastName(null);
1331                 expectedProductStrategistUser.setEmail("");
1332                 expectedProductStrategistUser.setRole("");
1333                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_OPERATION.name());
1334                 UserValidationUtils.validateAddUserAuditMessage(expectedProductStrategistUser, sdncDesignerUser,
1335                                 Integer.toString(STATUS_CODE_RESTRICTED_OPERATION), errorInfo.getAuditDesc(""),
1336                                 UserValidationUtils.getAddUserAuditMessage("AddUser"));
1337                 // Try to get user - user is not created
1338                 expectedProductStrategistUser.setUserId("pm1000");
1339                 expectedProductStrategistUser.setFirstName("Prod");
1340                 expectedProductStrategistUser.setLastName("Strategist");
1341                 expectedProductStrategistUser.setEmail("prodStr@intl.sdc.com");
1342                 expectedProductStrategistUser.setRole("PRODUCT_STRATEGIST");
1343                 RestResponse getUserResponse = UserRestUtils.getUser(expectedProductStrategistUser, sdncAdminUser);
1344                 assertEquals("Check response code ", STATUS_CODE_NOT_FOUND, getUserResponse.getErrorCode().intValue());
1345         }
1346
1347         @Test
1348         public void createProductManagerUserByNonAdminUser() throws Exception {
1349                 String httpCspUserId = "pm1000";
1350                 String userFirstName = "Prod";
1351                 String userLastName = "Man";
1352                 String email = "prodStr@intl.sdc.com";
1353                 String role = "PRODUCT_MANAGER";
1354                 User expectedProductStrategistUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
1355                 UserRestUtils.deleteUser(expectedProductStrategistUser, sdncAdminUser, true);
1356                 DbUtils.deleteFromEsDbByPattern("_all");
1357                 // create user
1358                 RestResponse createUserResponse = UserRestUtils.createUser(expectedProductStrategistUser, sdncDesignerUser);
1359                 assertEquals("Check response code after create Product-Manager user", STATUS_CODE_RESTRICTED_OPERATION,
1360                                 createUserResponse.getErrorCode().intValue());
1361                 // Audit validation
1362                 expectedProductStrategistUser.setUserId("");
1363                 expectedProductStrategistUser.setFirstName(null);
1364                 expectedProductStrategistUser.setLastName(null);
1365                 expectedProductStrategistUser.setEmail("");
1366                 expectedProductStrategistUser.setRole("");
1367                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_OPERATION.name());
1368                 UserValidationUtils.validateAddUserAuditMessage(expectedProductStrategistUser, sdncDesignerUser,
1369                                 Integer.toString(STATUS_CODE_RESTRICTED_OPERATION), errorInfo.getAuditDesc(""),
1370                                 UserValidationUtils.getAddUserAuditMessage("AddUser"));
1371                 // Try to get user - user is not created
1372                 expectedProductStrategistUser.setUserId("pm1000");
1373                 expectedProductStrategistUser.setFirstName("Prod");
1374                 expectedProductStrategistUser.setLastName("Strategist");
1375                 expectedProductStrategistUser.setEmail("prodStr@intl.sdc.com");
1376                 expectedProductStrategistUser.setRole("PRODUCT_MANAGER");
1377                 RestResponse getUserResponse = UserRestUtils.getUser(expectedProductStrategistUser, sdncAdminUser);
1378                 assertEquals("Check response code ", STATUS_CODE_NOT_FOUND, getUserResponse.getErrorCode().intValue());
1379         }
1380
1381         @Test
1382         public void createProductStrategistUserByNonExistingUser() throws Exception {
1383                 String httpCspUserId = "pm1000";
1384                 String userFirstName = "Prod";
1385                 String userLastName = "Strategist";
1386                 String email = "prodStr@intl.sdc.com";
1387                 String role = "PRODUCT_STRATEGIST";
1388                 User noSdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1389                 noSdncUserDetails.setRole("blabla");
1390                 noSdncUserDetails.setUserId("bt750h");
1391                 User expectedProductStrategistUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
1392                 DbUtils.deleteFromEsDbByPattern("_all");
1393                 // create user
1394                 RestResponse createUserResponse = UserRestUtils.createUser(expectedProductStrategistUser, noSdncUserDetails);
1395                 assertEquals("Check response code after create Product-Manager user", STATUS_CODE_NOT_FOUND,
1396                                 createUserResponse.getErrorCode().intValue());
1397                 // Audit validation
1398                 expectedProductStrategistUser.setUserId("");
1399                 expectedProductStrategistUser.setFirstName(null);
1400                 expectedProductStrategistUser.setLastName(null);
1401                 expectedProductStrategistUser.setEmail("");
1402                 expectedProductStrategistUser.setRole("");
1403                 noSdncUserDetails.setFirstName("");
1404                 noSdncUserDetails.setLastName("");
1405                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.USER_NOT_FOUND.name());
1406                 UserValidationUtils.validateAddUserAuditMessage(expectedProductStrategistUser, noSdncUserDetails,
1407                                 Integer.toString(STATUS_CODE_NOT_FOUND), errorInfo.getAuditDesc(noSdncUserDetails.getUserId()),
1408                                 UserValidationUtils.getAddUserAuditMessage("AddUser"));
1409                 // Try to get user - user is not created
1410                 expectedProductStrategistUser.setUserId("pm1000");
1411                 expectedProductStrategistUser.setFirstName("Prod");
1412                 expectedProductStrategistUser.setLastName("Strategist");
1413                 expectedProductStrategistUser.setEmail("prodStr@intl.sdc.com");
1414                 expectedProductStrategistUser.setRole("PRODUCT_STRATEGIST");
1415                 RestResponse getUserResponse = UserRestUtils.getUser(expectedProductStrategistUser, sdncAdminUser);
1416                 assertEquals("Check response code ", STATUS_CODE_NOT_FOUND, getUserResponse.getErrorCode().intValue());
1417         }
1418
1419         @Test
1420         public void createProductManagerUserByNonExistingUser() throws Exception {
1421                 String httpCspUserId = "pm1000";
1422                 String userFirstName = "Prod";
1423                 String userLastName = "Man";
1424                 String email = "prodStr@intl.sdc.com";
1425                 String role = "PRODUCT_MANAGER";
1426                 User noSdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1427                 noSdncUserDetails.setRole("blabla");
1428                 noSdncUserDetails.setUserId("bt750h");
1429                 User expectedProductStrategistUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
1430                 DbUtils.deleteFromEsDbByPattern("_all");
1431                 // create user
1432                 RestResponse createUserResponse = UserRestUtils.createUser(expectedProductStrategistUser, noSdncUserDetails);
1433                 assertEquals("Check response code after create Product-Manager user", STATUS_CODE_NOT_FOUND,
1434                                 createUserResponse.getErrorCode().intValue());
1435                 // Audit validation
1436                 expectedProductStrategistUser.setUserId("");
1437                 expectedProductStrategistUser.setFirstName(null);
1438                 expectedProductStrategistUser.setLastName(null);
1439                 expectedProductStrategistUser.setEmail("");
1440                 expectedProductStrategistUser.setRole("");
1441                 noSdncUserDetails.setFirstName("");
1442                 noSdncUserDetails.setLastName("");
1443                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.USER_NOT_FOUND.name());
1444                 UserValidationUtils.validateAddUserAuditMessage(expectedProductStrategistUser, noSdncUserDetails,
1445                                 Integer.toString(STATUS_CODE_NOT_FOUND), errorInfo.getAuditDesc(noSdncUserDetails.getUserId()),
1446                                 UserValidationUtils.getAddUserAuditMessage("AddUser"));
1447                 // Try to get user - user is not created
1448                 expectedProductStrategistUser.setUserId("pm1000");
1449                 expectedProductStrategistUser.setFirstName("Prod");
1450                 expectedProductStrategistUser.setLastName("Strategist");
1451                 expectedProductStrategistUser.setEmail("prodStr@intl.sdc.com");
1452                 expectedProductStrategistUser.setRole("PRODUCT_MANAGER");
1453                 RestResponse getUserResponse = UserRestUtils.getUser(expectedProductStrategistUser, sdncAdminUser);
1454                 assertEquals("Check response code ", STATUS_CODE_NOT_FOUND, getUserResponse.getErrorCode().intValue());
1455         }
1456
1457         @Test(enabled = false)
1458         public void updateProjectManagerRole() throws Exception {
1459                 // Update user role from PRODUCT_STRATEGIST to PRODUCT_MANAGER
1460                 String httpCspUserId = "pm1000";
1461                 String userFirstName = "Prod";
1462                 String userLastName = "Man";
1463                 String email = "prodMan@intl.sdc.com";
1464                 String role = "PRODUCT_MANAGER";
1465                 String updatedRole = "GOVERNOR";
1466                 User expectedProductManagerUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
1467                 deleteUserAndAudit(expectedProductManagerUser);
1468                 // create user
1469                 RestResponse createUserResponse = UserRestUtils.createUser(expectedProductManagerUser, sdncAdminUser);
1470                 assertEquals("Check response code after create Product-Manager user", STATUS_CODE_SUCSESS_CREATED,
1471                                 createUserResponse.getErrorCode().intValue());
1472                 UserValidationUtils.validateUserDetailsOnResponse(expectedProductManagerUser, createUserResponse.getResponse());
1473                 // Update user role
1474                 User newRoleUser = new User();
1475                 newRoleUser.setRole(updatedRole);
1476                 // Update user role from PRODUCT_STRATEGIST to PRODUCT_MANAGER
1477                 DbUtils.deleteFromEsDbByPattern("_all");
1478                 RestResponse updateUserRoleResponse = UserRestUtils.updateUserRole(newRoleUser, sdncAdminUser,
1479                                 expectedProductManagerUser.getUserId());
1480                 assertEquals("Check response code after create user", STATUS_CODE_SUCCESS,
1481                                 updateUserRoleResponse.getErrorCode().intValue());
1482                 expectedProductManagerUser.setRole(updatedRole);
1483                 UserValidationUtils.validateUserDetailsOnResponse(expectedProductManagerUser,
1484                                 updateUserRoleResponse.getResponse());
1485                 // Audit validation
1486                 UserValidationUtils.validateAddUserAuditMessage(expectedProductManagerUser, sdncAdminUser,
1487                                 Integer.toString(STATUS_CODE_SUCCESS), UserResponseMessageEnum.SUCCESS_MESSAGE.getValue(),
1488                                 UserValidationUtils.getAddUserAuditMessage("UpdateUser"));
1489                 // get user and compare with expected
1490                 RestResponse getUserResponse = UserRestUtils.getUser(expectedProductManagerUser, sdncAdminUser);
1491                 UserValidationUtils.validateUserDetailsOnResponse(expectedProductManagerUser, getUserResponse.getResponse());
1492                 // Delete ProductManager user
1493                 RestResponse deleteProductManagerUser = UserRestUtils.deleteUser(expectedProductManagerUser, sdncAdminUser,
1494                                 true);
1495                 assertEquals("Check response code after deleting OPS user", STATUS_CODE_SUCCESS,
1496                                 deleteProductManagerUser.getErrorCode().intValue());
1497         }
1498
1499         @Test(enabled = false)
1500         public void updateProductStrategistRole() throws Exception {
1501                 // Update user role from PRODUCT_STRATEGIST to PRODUCT_MANAGER
1502                 String httpCspUserId = "pm1000";
1503                 String userFirstName = "Prod";
1504                 String userLastName = "Strategist";
1505                 String email = "prodMan@intl.sdc.com";
1506                 String role = "PRODUCT_STRATEGIST";
1507                 String updatedRole = "TESTER";
1508                 User expectedProductManagerUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
1509                 deleteUserAndAudit(expectedProductManagerUser);
1510                 // create user
1511                 RestResponse createUserResponse = UserRestUtils.createUser(expectedProductManagerUser, sdncAdminUser);
1512                 assertEquals("Check response code after create Product-Manager user", STATUS_CODE_SUCSESS_CREATED,
1513                                 createUserResponse.getErrorCode().intValue());
1514                 UserValidationUtils.validateUserDetailsOnResponse(expectedProductManagerUser, createUserResponse.getResponse());
1515                 // Update user role
1516                 User newRoleUser = new User();
1517                 newRoleUser.setRole(updatedRole);
1518                 // Update user role from PRODUCT_STRATEGIST to PRODUCT_MANAGER
1519                 DbUtils.deleteFromEsDbByPattern("_all");
1520                 RestResponse updateUserRoleResponse = UserRestUtils.updateUserRole(newRoleUser, sdncAdminUser,
1521                                 expectedProductManagerUser.getUserId());
1522                 assertEquals("Check response code after create user", STATUS_CODE_SUCCESS,
1523                                 updateUserRoleResponse.getErrorCode().intValue());
1524                 expectedProductManagerUser.setRole(updatedRole);
1525                 UserValidationUtils.validateUserDetailsOnResponse(expectedProductManagerUser,
1526                                 updateUserRoleResponse.getResponse());
1527                 // Audit validation
1528                 UserValidationUtils.validateAddUserAuditMessage(expectedProductManagerUser, sdncAdminUser,
1529                                 Integer.toString(STATUS_CODE_SUCCESS), UserResponseMessageEnum.SUCCESS_MESSAGE.getValue(),
1530                                 UserValidationUtils.getAddUserAuditMessage("UpdateUser"));
1531                 // get user and compare with expected
1532                 RestResponse getUserResponse = UserRestUtils.getUser(expectedProductManagerUser, sdncAdminUser);
1533                 UserValidationUtils.validateUserDetailsOnResponse(expectedProductManagerUser, getUserResponse.getResponse());
1534                 // Delete ProductManager user
1535                 RestResponse deleteProductManagerUser = UserRestUtils.deleteUser(expectedProductManagerUser, sdncAdminUser,
1536                                 true);
1537                 assertEquals("Check response code after deleting OPS user", STATUS_CODE_SUCCESS,
1538                                 deleteProductManagerUser.getErrorCode().intValue());
1539         }
1540
1541         @Test
1542         public void createProductManagerUserAlreadyExit() throws Exception {
1543                 String httpCspUserId = "pm1000";
1544                 String userFirstName = "Prod";
1545                 String userLastName = "Man";
1546                 String email = "prodMan@intl.sdc.com";
1547                 String role = "PRODUCT_MANAGER";
1548                 User expectedProductManagerUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
1549                 deleteUserAndAudit(expectedProductManagerUser);
1550                 // create user
1551                 RestResponse createUserResponse = UserRestUtils.createUser(expectedProductManagerUser, sdncAdminUser);
1552                 assertEquals("Check response code after create Product-Manager user", STATUS_CODE_SUCSESS_CREATED,
1553                                 createUserResponse.getErrorCode().intValue());
1554                 UserValidationUtils.validateUserDetailsOnResponse(expectedProductManagerUser, createUserResponse.getResponse());
1555                 // create same user again
1556                 DbUtils.deleteFromEsDbByPattern("_all");
1557                 RestResponse createUserAgainResponse = UserRestUtils.createUser(expectedProductManagerUser, sdncAdminUser);
1558                 assertEquals("Check response code after create Product-Manager user", USER_ALREADY_EXIST,
1559                                 createUserAgainResponse.getErrorCode().intValue());
1560                 // Audit validation
1561                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.USER_ALREADY_EXIST.name());
1562                 UserValidationUtils.validateAddUserAuditMessage(expectedProductManagerUser, sdncAdminUser,
1563                                 Integer.toString(USER_ALREADY_EXIST), errorInfo.getAuditDesc(expectedProductManagerUser.getUserId()),
1564                                 UserValidationUtils.getAddUserAuditMessage("AddUser"));
1565                 // get user and compare with expected
1566                 RestResponse getUserResponse = UserRestUtils.getUser(expectedProductManagerUser, sdncAdminUser);
1567                 UserValidationUtils.validateUserDetailsOnResponse(expectedProductManagerUser, getUserResponse.getResponse());
1568                 // Delete ProductManager user
1569                 RestResponse deleteProductManagerUser = UserRestUtils.deleteUser(expectedProductManagerUser, sdncAdminUser,
1570                                 true);
1571                 assertEquals("Check response code after deleting OPS user", STATUS_CODE_SUCCESS,
1572                                 deleteProductManagerUser.getErrorCode().intValue());
1573         }
1574
1575         @Test
1576         public void createProductStrategistUserAlreadyExit() throws Exception {
1577                 String httpCspUserId = "pm1000";
1578                 String userFirstName = "Prod";
1579                 String userLastName = "Strategist";
1580                 String email = "prodMan@intl.sdc.com";
1581                 String role = "PRODUCT_STRATEGIST";
1582                 User expectedProductManagerUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
1583                 deleteUserAndAudit(expectedProductManagerUser);
1584                 // create user
1585                 RestResponse createUserResponse = UserRestUtils.createUser(expectedProductManagerUser, sdncAdminUser);
1586                 assertEquals("Check response code after create Product-Manager user", STATUS_CODE_SUCSESS_CREATED,
1587                                 createUserResponse.getErrorCode().intValue());
1588                 UserValidationUtils.validateUserDetailsOnResponse(expectedProductManagerUser, createUserResponse.getResponse());
1589                 // create same user again
1590                 DbUtils.deleteFromEsDbByPattern("_all");
1591                 RestResponse createUserAgainResponse = UserRestUtils.createUser(expectedProductManagerUser, sdncAdminUser);
1592                 assertEquals("Check response code after create Product-Manager user", USER_ALREADY_EXIST,
1593                                 createUserAgainResponse.getErrorCode().intValue());
1594                 // Audit validation
1595                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.USER_ALREADY_EXIST.name());
1596                 UserValidationUtils.validateAddUserAuditMessage(expectedProductManagerUser, sdncAdminUser,
1597                                 Integer.toString(USER_ALREADY_EXIST), errorInfo.getAuditDesc(expectedProductManagerUser.getUserId()),
1598                                 UserValidationUtils.getAddUserAuditMessage("AddUser"));
1599                 // get user and compare with expected
1600                 RestResponse getUserResponse = UserRestUtils.getUser(expectedProductManagerUser, sdncAdminUser);
1601                 UserValidationUtils.validateUserDetailsOnResponse(expectedProductManagerUser, getUserResponse.getResponse());
1602                 // Delete ProductManager user
1603                 RestResponse deleteProductManagerUser = UserRestUtils.deleteUser(expectedProductManagerUser, sdncAdminUser,
1604                                 true);
1605                 assertEquals("Check response code after deleting OPS user", STATUS_CODE_SUCCESS,
1606                                 deleteProductManagerUser.getErrorCode().intValue());
1607         }
1608
1609         @Test(enabled = false)
1610         public void UpdateProductStrategistToNonExistingRole() throws Exception {
1611                 String httpCspUserId = "pm1000";
1612                 String userFirstName = "Prod";
1613                 String userLastName = "Strategist";
1614                 String email = "prodMan@intl.sdc.com";
1615                 String role = "PRODUCT_STRATEGIST";
1616                 String nonExistingRole = "BLABLA";
1617                 User expectedProductStrategistUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
1618                 deleteUserAndAudit(expectedProductStrategistUser);
1619                 // create user
1620                 RestResponse createUserResponse = UserRestUtils.createUser(expectedProductStrategistUser, sdncAdminUser);
1621                 assertEquals("Check response code after create Product-Manager user", STATUS_CODE_SUCSESS_CREATED,
1622                                 createUserResponse.getErrorCode().intValue());
1623                 UserValidationUtils.validateUserDetailsOnResponse(expectedProductStrategistUser,
1624                                 createUserResponse.getResponse());
1625                 // Update user Role to non Existing role
1626                 User newRoleUser = new User();
1627                 newRoleUser.setRole(nonExistingRole);
1628                 DbUtils.deleteFromEsDbByPattern("_all");
1629                 RestResponse updateUserRoleResponse = UserRestUtils.updateUserRole(newRoleUser, sdncAdminUser,
1630                                 expectedProductStrategistUser.getUserId());
1631                 assertEquals("Check response code after updating user role", INVALID_ROLE,
1632                                 updateUserRoleResponse.getErrorCode().intValue());
1633
1634                 // Audit validation
1635                 /*
1636                  * expectedProductStrategistUser.setUserId("");
1637                  * expectedProductStrategistUser.setFirstName(null);
1638                  * expectedProductStrategistUser.setLastName(null);
1639                  * expectedProductStrategistUser.setEmail("");
1640                  * expectedProductStrategistUser.setRole("");
1641                  */
1642                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.INVALID_ROLE.name());
1643                 UserValidationUtils.validateAddUserAuditMessage(expectedProductStrategistUser, sdncAdminUser,
1644                                 Integer.toString(INVALID_ROLE), errorInfo.getAuditDesc(nonExistingRole),
1645                                 UserValidationUtils.getAddUserAuditMessage("UpdateUser"));
1646                 // get user and compare with expected
1647                 RestResponse getUserResponse = UserRestUtils.getUser(expectedProductStrategistUser, sdncAdminUser);
1648                 UserValidationUtils.validateUserDetailsOnResponse(expectedProductStrategistUser, getUserResponse.getResponse());
1649                 // Delete ProductManager user
1650                 RestResponse deleteProductManagerUser = UserRestUtils.deleteUser(expectedProductStrategistUser, sdncAdminUser,
1651                                 true);
1652                 assertEquals("Check response code after deleting OPS user", STATUS_CODE_SUCCESS,
1653                                 deleteProductManagerUser.getErrorCode().intValue());
1654         }
1655
1656         @Test(enabled = false)
1657         public void createUserWithNonExistingRole() throws Exception {
1658                 String httpCspUserId = "pm1000";
1659                 String userFirstName = "Prod";
1660                 String userLastName = "Strategist";
1661                 String email = "prodMan@intl.sdc.com";
1662                 String role = "BLABLA";
1663                 User expectedProductStrategistUser = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
1664                 deleteUserAndAudit(expectedProductStrategistUser);
1665                 // create user
1666                 RestResponse createUserResponse = UserRestUtils.createUser(expectedProductStrategistUser, sdncAdminUser);
1667                 assertEquals("Check response code after create Product-Manager user", INVALID_ROLE,
1668                                 createUserResponse.getErrorCode().intValue());
1669
1670                 // Audit validation
1671                 /*
1672                  * expectedProductStrategistUser.setUserId("");
1673                  * expectedProductStrategistUser.setFirstName(null);
1674                  * expectedProductStrategistUser.setLastName(null);
1675                  * expectedProductStrategistUser.setEmail("");
1676                  * expectedProductStrategistUser.setRole("");
1677                  */
1678                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.INVALID_ROLE.name());
1679                 UserValidationUtils.validateAddUserAuditMessage(expectedProductStrategistUser, sdncAdminUser,
1680                                 Integer.toString(INVALID_ROLE), errorInfo.getAuditDesc(role),
1681                                 UserValidationUtils.getAddUserAuditMessage("AddUser"));
1682                 // get user - verify user is not createdand compare with expected
1683                 RestResponse getUserResponse = UserRestUtils.getUser(expectedProductStrategistUser, sdncAdminUser);
1684                 assertEquals("Check user not created", STATUS_CODE_NOT_FOUND, getUserResponse.getErrorCode().intValue());
1685
1686         }
1687
1688         private void deleteUserAndAudit(User sdncUserDetails) throws IOException {
1689                 UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
1690                 DbUtils.cleanAllAudits();
1691         }
1692
1693 }