test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/user/ActivateDeActivateDeleteUser.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.assertFalse;
  25 import static org.testng.AssertJUnit.assertNotNull;
  26 import static org.testng.AssertJUnit.assertTrue;
  27
  28 import java.util.ArrayList;
  29 import java.util.Arrays;
  30 import java.util.HashMap;
  31 import java.util.List;
  32 import java.util.Map;
  33 import java.util.Map.Entry;
  34
  35 import org.apache.http.HttpStatus;
  36 import org.junit.Rule;
  37 import org.junit.rules.TestName;
  38 import org.openecomp.sdc.be.dao.api.ActionStatus;
  39 import org.openecomp.sdc.be.dao.utils.UserStatusEnum;
  40 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  41 import org.openecomp.sdc.be.model.Resource;
  42 import org.openecomp.sdc.be.model.User;
  43 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  44 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  45 import org.openecomp.sdc.ci.tests.datatypes.ResourceRespJavaObject;
  46 import org.openecomp.sdc.ci.tests.datatypes.ServiceReqDetails;
  47 import org.openecomp.sdc.ci.tests.datatypes.enums.ErrorInfo;
  48 import org.openecomp.sdc.ci.tests.datatypes.enums.NormativeTypesEnum;
  49 import org.openecomp.sdc.ci.tests.datatypes.enums.ResourceCategoryEnum;
  50 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  51 import org.openecomp.sdc.ci.tests.datatypes.expected.ExpectedUserCRUDAudit;
  52 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  53 import org.openecomp.sdc.ci.tests.users.UserResponseMessageEnum;
  54 import org.openecomp.sdc.ci.tests.utils.DbUtils;
  55 import org.openecomp.sdc.ci.tests.utils.general.Convertor;
  56 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  57 import org.openecomp.sdc.ci.tests.utils.rest.CatalogRestUtils;
  58 import org.openecomp.sdc.ci.tests.utils.rest.ImportRestUtils;
  59 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils;
  60 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  61 import org.openecomp.sdc.ci.tests.utils.rest.UserRestUtils;
  62 import org.openecomp.sdc.ci.tests.utils.validation.AuditValidationUtils;
  63 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  64 import org.openecomp.sdc.ci.tests.utils.validation.ResourceValidationUtils;
  65 import org.openecomp.sdc.ci.tests.utils.validation.UserValidationUtils;
  66 import org.slf4j.Logger;
  67 import org.slf4j.LoggerFactory;
  68 import org.testng.AssertJUnit;
  69 import org.testng.annotations.BeforeMethod;
  70 import org.testng.annotations.Test;
  71
  72 import com.google.gson.Gson;
  73 import com.google.gson.JsonArray;
  74 import com.google.gson.JsonElement;
  75 import com.google.gson.JsonObject;
  76 import com.google.gson.JsonParser;
  77 import com.google.gson.reflect.TypeToken;
  78
  79 /**
  80  * @author alitvinsky
  81  *
  82  */
  83 public class ActivateDeActivateDeleteUser extends ComponentBaseTest {
  84         private static Logger logger = LoggerFactory.getLogger(ActivateDeActivateDeleteUser.class.getName());
  85         protected Gson gson = new Gson();
  86         protected User sdncAdminUser;
  87
  88         @BeforeMethod
  89         public void init() {
  90                 sdncAdminUser = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
  91
  92         }
  93
  94         @Rule
  95         public static TestName name = new TestName();
  96
  97         public ActivateDeActivateDeleteUser() {
  98                 super(name, ActivateDeActivateDeleteUser.class.getName());
  99         }
 100
 101         @Test
 102         public void authorizeDeActivatedUser() throws Exception {
 103
 104                 User sdncUserDetails = getDefaultUserDetails();
 105
 106                 try {
 107
 108                         UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
 109                         DbUtils.cleanAllAudits();
 110
 111                         RestResponse createUserResponse = UserRestUtils.createUser(sdncUserDetails, sdncAdminUser);
 112                         validateSuccessCreateUserResponse(sdncUserDetails, createUserResponse);
 113
 114                         // deActivate created user
 115                         RestResponse deActivateUserResponse = UserRestUtils.deActivateUser(sdncUserDetails, sdncAdminUser);
 116                         sdncUserDetails.setStatus(UserStatusEnum.INACTIVE);
 117                         validateSuccessDeActivateUserResponse(sdncUserDetails, deActivateUserResponse);
 118
 119                         ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.USER_INACTIVE.name());
 120                         RestResponse getUserResponse = UserRestUtils.getUser(sdncUserDetails, sdncAdminUser);
 121
 122                         AssertJUnit.assertEquals("Check response code after deActive user", errorInfo.getCode(),
 123                                         getUserResponse.getErrorCode());
 124
 125                         List<String> variables = Arrays.asList(sdncUserDetails.getUserId());
 126                         ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.USER_INACTIVE.name(), variables,
 127                                         getUserResponse.getResponse());
 128
 129                         // clean audit before authorization test
 130                         DbUtils.cleanAllAudits();
 131
 132                         // Perform login from WebSeal
 133                         User sealUserDetails = sdncUserDetails;
 134                         RestResponse authorizedUserResponse = UserRestUtils.authorizedUserTowardsCatalogBeQA(sealUserDetails);
 135
 136                         // validate response
 137
 138                         ErrorInfo errorInfo2 = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_ACCESS.name());
 139
 140                         AssertJUnit.assertNotNull("check response object is not null after user login", authorizedUserResponse);
 141                         AssertJUnit.assertNotNull("check error code exists in response after user login",
 142                                         authorizedUserResponse.getErrorCode());
 143                         AssertJUnit.assertEquals("Check response code after deActive user", errorInfo2.getCode(),
 144                                         authorizedUserResponse.getErrorCode());
 145
 146                         List<String> variables2 = Arrays.asList();
 147                         ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_ACCESS.name(), variables2,
 148                                         authorizedUserResponse.getResponse());
 149
 150                         // validate against ES DB
 151
 152                         UserValidationUtils.validateDataAgainstAuditDB_access(sealUserDetails,
 153                                         DbUtils.parseAuditRespByAction("Access"), authorizedUserResponse, errorInfo2, variables2);
 154
 155                 } finally {
 156                         UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
 157                 }
 158
 159         }
 160
 161         public User getDefaultUserDetails() {
 162
 163                 String httpCspUserId = "km2000";
 164                 String userFirstName = "Kot";
 165                 String userLastName = "May";
 166                 String email = "km2000@intl.sdc.com";
 167                 String role = UserRoleEnum.ADMIN.name();
 168                 User sdncUserDetails = new User(userFirstName, userLastName, httpCspUserId, email, role, null);
 169
 170                 return sdncUserDetails;
 171         }
 172
 173         public void validateSuccessCreateUserResponse(User sdncUserDetails, RestResponse createUserResponse)
 174                         throws Exception {
 175
 176                 AssertJUnit.assertNotNull("check response object is not null after create user", createUserResponse);
 177                 AssertJUnit.assertNotNull("check error code exists in response after create user",
 178                                 createUserResponse.getErrorCode());
 179                 AssertJUnit.assertEquals("Check response code after create user", HttpStatus.SC_CREATED,
 180                                 createUserResponse.getErrorCode().intValue());
 181
 182                 UserValidationUtils.validateUserDetailsOnResponse(sdncUserDetails, createUserResponse.getResponse());
 183                 // UserRestUtils.validateAddUserAuditMessage(sdncUserDetails,
 184                 // sdncAdminUser, String.valueOf(HttpStatus.SC_CREATED),
 185                 // UserResponseMessageEnum.SUCCESS_MESSAGE.getValue(),
 186                 // UserRestUtils.getAddUserAuditMessage("AddUser"));
 187                 String addUser = "AddUser";
 188                 ExpectedUserCRUDAudit constructFieldsForAuditValidation = Convertor.constructFieldsForAuditValidation(addUser,
 189                                 sdncAdminUser, ActionStatus.CREATED, sdncUserDetails, null);
 190                 AuditValidationUtils.validateAddUserAudit(constructFieldsForAuditValidation, addUser);
 191
 192                 RestResponse getUserResponse = UserRestUtils.getUser(sdncUserDetails, sdncAdminUser);
 193                 UserValidationUtils.validateUserDetailsOnResponse(sdncUserDetails, getUserResponse.getResponse());
 194
 195         }
 196
 197         public void validateSuccessDeActivateUserResponse(User sdncUserDetails, RestResponse deActivateUserResponse)
 198                         throws Exception {
 199
 200                 AssertJUnit.assertNotNull("check response object is not null after deActive user", deActivateUserResponse);
 201                 AssertJUnit.assertNotNull("check error code exists in response after deActive user",
 202                                 deActivateUserResponse.getErrorCode());
 203                 AssertJUnit.assertEquals("Check response code after deActive user", 200,
 204                                 deActivateUserResponse.getErrorCode().intValue());
 205
 206                 UserValidationUtils.validateUserDetailsOnResponse(sdncUserDetails, deActivateUserResponse.getResponse());
 207
 208                 String deleteUser = "DeleteUser";
 209                 ExpectedUserCRUDAudit constructFieldsForAuditValidation = Convertor
 210                                 .constructFieldsForAuditValidation(deleteUser, sdncAdminUser, ActionStatus.OK, null, sdncUserDetails);
 211                 AuditValidationUtils.validateAddUserAudit(constructFieldsForAuditValidation, deleteUser);
 212
 213         }
 214
 215         // US498322 - Add Status Field to USER
 216
 217         @Test
 218         public void createNewUser() throws Exception {
 219
 220                 User sdncUserDetails = getDefaultUserDetails();
 221                 try {
 222
 223                         UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
 224                         DbUtils.cleanAllAudits();
 225
 226                         RestResponse createUserResponse = UserRestUtils.createUser(sdncUserDetails, sdncAdminUser);
 227                         validateSuccessCreateUserResponse(sdncUserDetails, createUserResponse);
 228
 229                 } finally {
 230                         UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
 231                 }
 232
 233         }
 234
 235         @Test
 236         public void createDefaultUser() throws Exception {
 237
 238                 User sdncUserDetails = getDefaultUserDetails();
 239                 sdncUserDetails.setFirstName(null);
 240                 sdncUserDetails.setLastName(null);
 241                 sdncUserDetails.setEmail(null);
 242                 sdncUserDetails.setRole(null);
 243
 244                 try {
 245
 246                         UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
 247                         DbUtils.cleanAllAudits();
 248
 249                         RestResponse createUserResponse = UserRestUtils.createUser(sdncUserDetails, sdncAdminUser);
 250                         validateSuccessCreateUserResponse(sdncUserDetails, createUserResponse);
 251
 252                 } finally {
 253                         UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
 254                 }
 255
 256         }
 257
 258         @Test
 259         public void createTesterUser() throws Exception {
 260
 261                 User sdncUserDetails = getDefaultUserDetails();
 262                 sdncUserDetails.setLastName(null);
 263                 sdncUserDetails.setRole(UserRoleEnum.TESTER.name());
 264
 265                 try {
 266
 267                         UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
 268                         DbUtils.cleanAllAudits();
 269
 270                         RestResponse createUserResponse = UserRestUtils.createUser(sdncUserDetails, sdncAdminUser);
 271                         validateSuccessCreateUserResponse(sdncUserDetails, createUserResponse);
 272
 273                 } finally {
 274                         UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
 275                 }
 276
 277         }
 278
 279         @Test
 280         public void deActivateCreatedAdminUser() throws Exception {
 281
 282                 User sdncUserDetails = getDefaultUserDetails();
 283
 284                 try {
 285
 286                         UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
 287                         DbUtils.cleanAllAudits();
 288
 289                         RestResponse createUserResponse = UserRestUtils.createUser(sdncUserDetails, sdncAdminUser);
 290                         validateSuccessCreateUserResponse(sdncUserDetails, createUserResponse);
 291
 292                         // deActivate created user
 293                         RestResponse deActivateUserResponse = UserRestUtils.deActivateUser(sdncUserDetails, sdncAdminUser);
 294                         sdncUserDetails.setStatus(UserStatusEnum.INACTIVE);
 295                         validateSuccessDeActivateUserResponse(sdncUserDetails, deActivateUserResponse);
 296
 297                         ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.USER_INACTIVE.name());
 298
 299                         RestResponse getUserResponse = UserRestUtils.getUser(sdncUserDetails, sdncAdminUser);
 300
 301                         assertEquals("Check response code after get user", errorInfo.getCode(), getUserResponse.getErrorCode());
 302
 303                         List<String> variables = Arrays.asList(sdncUserDetails.getUserId());
 304                         ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.USER_INACTIVE.name(), variables,
 305                                         getUserResponse.getResponse());
 306
 307                 } finally {
 308                         UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
 309                 }
 310
 311         }
 312
 313         @Test
 314         public void deActivateTheSameUserTwice() throws Exception {
 315
 316                 User sdncUserDetails = getDefaultUserDetails();
 317
 318                 try {
 319
 320                         UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
 321                         DbUtils.cleanAllAudits();
 322
 323                         RestResponse createUserResponse = UserRestUtils.createUser(sdncUserDetails, sdncAdminUser);
 324                         validateSuccessCreateUserResponse(sdncUserDetails, createUserResponse);
 325
 326                         // deActivate created user
 327                         RestResponse deActivateUserResponse = UserRestUtils.deActivateUser(sdncUserDetails, sdncAdminUser);
 328                         sdncUserDetails.setStatus(UserStatusEnum.INACTIVE);
 329                         validateSuccessDeActivateUserResponse(sdncUserDetails, deActivateUserResponse);
 330
 331                         ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.USER_INACTIVE.name());
 332
 333                         RestResponse getUserResponse = UserRestUtils.getUser(sdncUserDetails, sdncAdminUser);
 334
 335                         assertEquals("Check response code after deActive user", errorInfo.getCode(),
 336                                         getUserResponse.getErrorCode());
 337
 338                         List<String> variables = Arrays.asList(sdncUserDetails.getUserId());
 339                         ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.USER_INACTIVE.name(), variables,
 340                                         getUserResponse.getResponse());
 341
 342                         // deActivate the same user once time more
 343                         RestResponse deActivateUserResponse2 = UserRestUtils.deActivateUser(sdncUserDetails, sdncAdminUser);
 344                         ErrorInfo errorInfo2 = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.USER_INACTIVE.name());
 345                         assertEquals("Check response code after deActive user", errorInfo2.getCode(),
 346                                         deActivateUserResponse2.getErrorCode());
 347
 348                         List<String> variables2 = Arrays.asList(sdncUserDetails.getUserId());
 349                         ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.USER_INACTIVE.name(), variables2,
 350                                         deActivateUserResponse2.getResponse());
 351
 352                 } finally {
 353                         UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
 354                 }
 355
 356         }
 357
 358         @Test
 359         public void createAgainDeActivatedUser() throws Exception {
 360
 361                 User sdncUserDetails = getDefaultUserDetails();
 362
 363                 try {
 364
 365                         UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
 366                         DbUtils.cleanAllAudits();
 367
 368                         RestResponse createUserResponse = UserRestUtils.createUser(sdncUserDetails, sdncAdminUser);
 369                         validateSuccessCreateUserResponse(sdncUserDetails, createUserResponse);
 370
 371                         // deActivate created user
 372                         RestResponse deActivateUserResponse = UserRestUtils.deActivateUser(sdncUserDetails, sdncAdminUser);
 373                         sdncUserDetails.setStatus(UserStatusEnum.INACTIVE);
 374                         validateSuccessDeActivateUserResponse(sdncUserDetails, deActivateUserResponse);
 375
 376                         ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.USER_INACTIVE.name());
 377                         RestResponse getUserResponse = UserRestUtils.getUser(sdncUserDetails, sdncAdminUser);
 378
 379                         assertEquals("Check response code after deActive user", errorInfo.getCode(),
 380                                         getUserResponse.getErrorCode());
 381
 382                         List<String> variables = Arrays.asList(sdncUserDetails.getUserId());
 383                         ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.USER_INACTIVE.name(), variables,
 384                                         getUserResponse.getResponse());
 385
 386                         // create the user with the same UserId(details) as deActivated user
 387                         DbUtils.cleanAllAudits();
 388
 389                         RestResponse createUserResponse2 = UserRestUtils.createUser(sdncUserDetails, sdncAdminUser);
 390                         ErrorInfo errorInfo2 = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.USER_INACTIVE.name());
 391                         assertEquals("Check response code after deActive user", errorInfo2.getCode(),
 392                                         createUserResponse2.getErrorCode());
 393
 394                         List<String> variables2 = Arrays.asList(sdncUserDetails.getUserId());
 395                         ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.USER_INACTIVE.name(), variables2,
 396                                         createUserResponse2.getResponse());
 397
 398                 } finally {
 399                         UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
 400                 }
 401
 402         }
 403
 404         // very not recommend to run this test, resources/services may be zombie
 405         // @Test
 406         public void deActivateLastAdminUser() throws Exception {
 407
 408                 try {
 409
 410                         // send get all ADMIN user request toward BE
 411                         RestResponse getAllAdminUsers = UserRestUtils.getAllAdminUsers(sdncAdminUser);
 412
 413                         assertNotNull("check response object is not null after create user", getAllAdminUsers);
 414                         assertNotNull("check error code exists in response after create user", getAllAdminUsers.getErrorCode());
 415                         assertEquals("Check response code after create user", 200, getAllAdminUsers.getErrorCode().intValue());
 416
 417                         TypeToken<List<User>> typeToken = new TypeToken<List<User>>() {
 418                         };
 419                         List<User> listOfUsersOnResponse = gson.fromJson(getAllAdminUsers.getResponse(), typeToken.getType());
 420                         logger.debug("listOfUsers: {}", listOfUsersOnResponse);
 421
 422                         // build map of all Admin users from listOfUsersOnResponse from
 423                         // response
 424                         Map<String, User> mapAllUsersOnResponse = new HashMap<String, User>();
 425                         for (User sdncUser : listOfUsersOnResponse) {
 426                                 mapAllUsersOnResponse.put(sdncUser.getUserId(), sdncUser);
 427                         }
 428
 429                         // remove from mapAllUsersOnResponse map one of admin users
 430                         mapAllUsersOnResponse.remove(sdncAdminUser.getUserId());
 431                         logger.debug("map Of all Admin users exclude one : {}", mapAllUsersOnResponse);
 432
 433                         // deActivate all Admin users from the userIdAllAdminList list
 434                         for (Entry<String, User> entry : mapAllUsersOnResponse.entrySet()) {
 435                                 UserRestUtils.deActivateUser(entry.getValue(), sdncAdminUser);
 436                         }
 437
 438                         // deActivate last Admin user user
 439                         RestResponse deActivateUserResponse = UserRestUtils.deActivateUser(sdncAdminUser, sdncAdminUser);
 440
 441                         ErrorInfo errorInfo = ErrorValidationUtils
 442                                         .parseErrorConfigYaml(ActionStatus.DELETE_USER_ADMIN_CONFLICT.name());
 443
 444                         assertEquals("Check response code after deActive user", errorInfo.getCode(),
 445                                         deActivateUserResponse.getErrorCode());
 446
 447                         List<String> variables = Arrays.asList();
 448                         ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.DELETE_USER_ADMIN_CONFLICT.name(), variables,
 449                                         deActivateUserResponse.getResponse());
 450
 451                 } finally {
 452                         // UserRestUtils.deleteUser(UserRestUtils.getAdminDetails2(),
 453                         // sdncAdminUser);
 454                         // UserRestUtils.deleteUser(UserRestUtils.getAdminDetails3(),
 455                         // sdncAdminUser);
 456                         // UserRestUtils.createUser(UserRestUtils.getAdminDetails2(),
 457                         // sdncAdminUser);
 458                         // UserRestUtils.createUser(UserRestUtils.getAdminDetails3(),
 459                         // sdncAdminUser);
 460                 }
 461
 462         }
 463
 464         // test check the resource accessibility via catalog view, resource was
 465         // created by user which was deActivated
 466
 467         @Test
 468         public void resourceAccessibility() throws Exception {
 469
 470                 User sdncUserDetails = getDefaultUserDetails();
 471                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource("tosca.nodes.newresource4test4",
 472                                 NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, "jh0003");
 473                 String resourceBaseVersion = "0.1";
 474
 475                 try {
 476                         // Delete resource
 477                         // resourceUtils.deleteResource_allVersions(resourceDetails,
 478                         // sdncAdminUser);
 479                         UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
 480
 481                         DbUtils.cleanAllAudits();
 482                         RestResponse createUserResponse = UserRestUtils.createUser(sdncUserDetails, sdncAdminUser);
 483                         validateSuccessCreateUserResponse(sdncUserDetails, createUserResponse);
 484
 485                         // ------------------------Start create
 486                         // resource---------------------------------------------------------------------------------
 487
 488                         // create resource
 489                         RestResponse createResponse = ResourceRestUtils.createResource(resourceDetails, sdncUserDetails);
 490                         assertEquals("Check response code after create", 201, createResponse.getErrorCode().intValue());
 491
 492                         Resource createdResource = ResponseParser.convertResourceResponseToJavaObject(createResponse.getResponse());
 493
 494                         RestResponse resourceGetResponse = ResourceRestUtils.getResource(sdncUserDetails,
 495                                         createdResource.getUniqueId());
 496                         assertEquals("Check response code after get", 200, resourceGetResponse.getErrorCode().intValue());
 497
 498                         // validate get response
 499                         ResourceRespJavaObject resourceRespJavaObject = Convertor.constructFieldsForRespValidation(resourceDetails,
 500                                         resourceBaseVersion);
 501                         resourceRespJavaObject.setLifecycleState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 502                         resourceRespJavaObject.setAbstractt("false");
 503                         resourceRespJavaObject.setCreatorUserId(sdncUserDetails.getUserId());
 504                         resourceRespJavaObject.setLastUpdaterUserId(sdncUserDetails.getUserId());
 505
 506                         resourceRespJavaObject
 507                                         .setCreatorFullName(sdncUserDetails.getFirstName() + " " + sdncUserDetails.getLastName());
 508                         resourceRespJavaObject
 509                                         .setLastUpdaterFullName(sdncUserDetails.getFirstName() + " " + sdncUserDetails.getLastName());
 510
 511                         ResourceValidationUtils.validateResp(resourceGetResponse, resourceRespJavaObject);
 512
 513                         // ------------------------End create
 514                         // resource---------------------------------------------------------------------------------
 515
 516                         // clean audit before authorization test
 517                         DbUtils.cleanAllAudits();
 518
 519                         // deActivate created user
 520                         RestResponse deActivateUserResponse = UserRestUtils.deActivateUser(sdncUserDetails, sdncAdminUser);
 521                         sdncUserDetails.setStatus(UserStatusEnum.INACTIVE);
 522                         validateSuccessDeActivateUserResponse(sdncUserDetails, deActivateUserResponse);
 523
 524                         UserValidationUtils.validateDeleteUserAuditMessage(sdncUserDetails, sdncAdminUser, "200",
 525                                         UserResponseMessageEnum.SUCCESS_MESSAGE.getValue(),
 526                                         UserValidationUtils.getAddUserAuditMessage("DeleteUser"));
 527
 528                         ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.USER_INACTIVE.name());
 529                         RestResponse getUserResponse = UserRestUtils.getUser(sdncUserDetails, sdncAdminUser);
 530
 531                         assertEquals("Check response code after deActive user", errorInfo.getCode(),
 532                                         getUserResponse.getErrorCode());
 533
 534                         List<String> variables = Arrays.asList(sdncUserDetails.getUserId());
 535                         ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.USER_INACTIVE.name(), variables,
 536                                         getUserResponse.getResponse());
 537
 538                         // checking if created resource is accessible
 539                         DbUtils.cleanAllAudits();
 540
 541                         RestResponse getCatalogDataResponse = CatalogRestUtils.getCatalog(sdncAdminUser.getUserId());
 542
 543                         // validate response
 544
 545                         assertNotNull("check response object is not null after user login", getCatalogDataResponse);
 546                         assertNotNull("check error code exists in response after user login",
 547                                         getCatalogDataResponse.getErrorCode());
 548                         assertEquals("Check response code after deActive user", 200,
 549                                         getCatalogDataResponse.getErrorCode().intValue());
 550
 551                         // expected resource list
 552                         List<String> resourceExpectedUniqIdList = new ArrayList<String>();
 553                         resourceExpectedUniqIdList.add(resourceDetails.getUniqueId());
 554                         logger.debug("resourceExpectedUniqIdList: {}", resourceExpectedUniqIdList);
 555
 556                         compareResourceUniqIdList(getCatalogDataResponse.getResponse(), resourceExpectedUniqIdList, true);
 557
 558                 } finally {
 559                         // resourceUtils.deleteResource_allVersions(resourceDetails,
 560                         // sdncAdminUser);
 561                         UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
 562                 }
 563
 564         }
 565
 566         // test check the resource accessibility via catalog view, resource was
 567         // created by user which was deActivated
 568
 569         @Test
 570         public void resourceAccessibilityOnImport() throws Exception {
 571
 572                 User sdncUserDetails = getDefaultUserDetails();
 573                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource("importResource4test",
 574                                 NormativeTypesEnum.ROOT, ResourceCategoryEnum.NETWORK_L2_3_ROUTERS, "jh0003");
 575                 resourceDetails.addCategoryChain(ResourceCategoryEnum.GENERIC_DATABASE.getCategory(),
 576                                 ResourceCategoryEnum.GENERIC_DATABASE.getSubCategory());
 577                 // String resourceBaseVersion = "1.0";
 578
 579                 try {
 580                         // Delete resource
 581                         // resourceUtils.deleteResource_allVersions(resourceDetails,
 582                         // sdncAdminUser);
 583                         RestResponse deleteUserResponse = UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
 584                         assertTrue("delete user request failed",
 585                                         deleteUserResponse.getErrorCode() == 200 || deleteUserResponse.getErrorCode() == 404);
 586                         DbUtils.cleanAllAudits();
 587                         RestResponse createUserResponse = UserRestUtils.createUser(sdncUserDetails, sdncAdminUser);
 588                         validateSuccessCreateUserResponse(sdncUserDetails, createUserResponse);
 589
 590                         // ------------------------Start import
 591                         // resource---------------------------------------------------------------------------------
 592
 593                         // import new resource with CERTIFIED state
 594                         User importer = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN4);
 595                         RestResponse importResponse = ImportRestUtils.importResourceByName(resourceDetails, importer);
 596
 597                         assertNotNull("check response object is not null after create user", importResponse);
 598                         assertNotNull("check error code exists in response after create user", importResponse.getErrorCode());
 599                         assertEquals("Check response code after create user", 201, importResponse.getErrorCode().intValue());
 600
 601                         // ------------------------End import
 602                         // resource---------------------------------------------------------------------------------
 603
 604                         // clean audit before authorization test
 605                         DbUtils.cleanAllAudits();
 606
 607                         // deActivate created user
 608                         RestResponse deActivateUserResponse = UserRestUtils.deActivateUser(sdncUserDetails, sdncAdminUser);
 609                         sdncUserDetails.setStatus(UserStatusEnum.INACTIVE);
 610                         validateSuccessDeActivateUserResponse(sdncUserDetails, deActivateUserResponse);
 611
 612                         UserValidationUtils.validateDeleteUserAuditMessage(sdncUserDetails, sdncAdminUser, "200",
 613                                         UserResponseMessageEnum.SUCCESS_MESSAGE.getValue(),
 614                                         UserValidationUtils.getAddUserAuditMessage("DeleteUser"));
 615
 616                         ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.USER_INACTIVE.name());
 617                         RestResponse getUserResponse = UserRestUtils.getUser(sdncUserDetails, sdncAdminUser);
 618
 619                         assertEquals("Check response code after deActive user", errorInfo.getCode(),
 620                                         getUserResponse.getErrorCode());
 621
 622                         List<String> variables = Arrays.asList(sdncUserDetails.getUserId());
 623                         ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.USER_INACTIVE.name(), variables,
 624                                         getUserResponse.getResponse());
 625
 626                         // checking if created resource is accessible
 627                         DbUtils.cleanAllAudits();
 628
 629                         RestResponse getCatalogDataResponse = CatalogRestUtils.getCatalog(sdncAdminUser.getUserId());
 630
 631                         // validate response
 632
 633                         assertNotNull("check response object is not null after user login", getCatalogDataResponse);
 634                         assertNotNull("check error code exists in response after user login",
 635                                         getCatalogDataResponse.getErrorCode());
 636                         assertEquals("Check response code after deActive user", 200,
 637                                         getCatalogDataResponse.getErrorCode().intValue());
 638
 639                         // expected resource list
 640                         List<String> resourceExpectedUniqIdList = new ArrayList<String>();
 641                         resourceExpectedUniqIdList.add(resourceDetails.getUniqueId());
 642                         logger.debug("resourceExpectedUniqIdList: {}", resourceExpectedUniqIdList);
 643
 644                         compareResourceUniqIdList(getCatalogDataResponse.getResponse(), resourceExpectedUniqIdList, true);
 645
 646                 } finally {
 647                         // resourceUtils.deleteResource_allVersions(resourceDetails,
 648                         // sdncAdminUser);
 649                         UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
 650                 }
 651
 652         }
 653
 654         public void compareServiceUniqIdList(String response, List<String> expectedList, boolean flag) {
 655
 656                 JsonElement jelement = new JsonParser().parse(response);
 657                 JsonObject jobject = jelement.getAsJsonObject();
 658                 JsonArray serviceArray = (JsonArray) jobject.get("services");
 659                 logger.debug("{}", serviceArray);
 660                 assertTrue("expected service count: " + expectedList.size() + " or more" + ", actual: " + serviceArray.size(),
 661                                 serviceArray.size() >= expectedList.size());
 662
 663                 // build service list from response
 664                 List<ServiceReqDetails> serviceReqDetailsListOnResponse = new ArrayList<ServiceReqDetails>();
 665                 for (int i = 0; i < serviceArray.size(); i++) {
 666                         ServiceReqDetails json = gson.fromJson(serviceArray.get(i), ServiceReqDetails.class);
 667                         serviceReqDetailsListOnResponse.add(json);
 668                 }
 669         }
 670
 671         public void compareResourceUniqIdList(String response, List<String> expectedList, boolean flag) {
 672
 673                 JsonElement jelement = new JsonParser().parse(response);
 674                 JsonObject jobject = jelement.getAsJsonObject();
 675                 JsonArray resourceArray = (JsonArray) jobject.get("resources");
 676                 logger.debug("{}", resourceArray);
 677                 assertTrue("expected resource count: " + expectedList.size() + " or more" + ", actual: " + resourceArray.size(),
 678                                 resourceArray.size() >= expectedList.size());
 679
 680                 // build resource list from response
 681                 List<ResourceReqDetails> resourceReqDetailsListOnResponse = new ArrayList<ResourceReqDetails>();
 682                 for (int i = 0; i < resourceArray.size(); i++) {
 683                         ResourceReqDetails json = gson.fromJson(resourceArray.get(i), ResourceReqDetails.class);
 684                         resourceReqDetailsListOnResponse.add(json);
 685                 }
 686
 687                 logger.debug("ResourceReqDetails list on response: {}", resourceReqDetailsListOnResponse);
 688
 689                 List<String> resourceActualUniqIdList = new ArrayList<String>();
 690                 for (ResourceReqDetails resource : resourceReqDetailsListOnResponse) {
 691                         resourceActualUniqIdList.add(resource.getUniqueId());
 692                 }
 693                 logger.debug("resourceActualUniqIdList on response: {}", resourceActualUniqIdList);
 694                 logger.debug("resourceExpectedUniqIdList on response: {}", expectedList);
 695
 696                 if (flag) {
 697                         assertTrue("actual list does not contain expected list",
 698                                         resourceActualUniqIdList.containsAll(expectedList));
 699                 } else {
 700                         assertFalse("actual list contains non expected list elements",
 701                                         resourceActualUniqIdList.containsAll(expectedList));
 702                 }
 703         }
 704
 705         // public User getDefaultUserDetails(){
 706         //
 707         // String userFirstName = "Kot";
 708         // String userLastName = "May";
 709         // String role = UserRoleEnum.ADMIN.name();
 710         // User sdncUserDetails = new User(userFirstName, userLastName,
 711         // httpCspUserId, email, role,null);
 712         //
 713         // return sdncUserDetails;
 714         // }
 715         //
 716         // public void validateSuccessCreateUserResponse(User sdncUserDetails,
 717         // RestResponse createUserResponse) throws Exception{
 718         //
 719         // assertNotNull("check response object is not null after create user",
 720         // createUserResponse);
 721         // assertNotNull("check error code exists in response after create user",
 722         // createUserResponse.getErrorCode());
 723         // assertEquals("Check response code after create user",
 724         // HttpStatus.SC_CREATED, createUserResponse.getErrorCode().intValue());
 725         //
 726         // UserRestUtils.validateUserDetailsOnResponse(sdncUserDetails,
 727         // createUserResponse.getResponse());
 728         // UserRestUtils.validateAddUserAuditMessage(sdncUserDetails, sdncAdminUser,
 729         // String.valueOf(HttpStatus.SC_CREATED),
 730         // UserResponseMessageEnum.SUCCESS_MESSAGE.getValue(),
 731         // UserRestUtils.getAddUserAuditMessage("AddUser"));
 732         // RestResponse getUserResponse = UserRestUtils.getUser(sdncUserDetails,
 733         // sdncAdminUser);
 734         // UserRestUtils.validateUserDetailsOnResponse(sdncUserDetails,
 735         // getUserResponse.getResponse());
 736         //
 737         // }
 738         //
 739         // public void validateSuccessDeActivateUserResponse(User sdncUserDetails,
 740         // RestResponse deActivateUserResponse) throws Exception{
 741         //
 742         // assertNotNull("check response object is not null after deActive user",
 743         // deActivateUserResponse);
 744         // assertNotNull("check error code exists in response after deActive user",
 745         // deActivateUserResponse.getErrorCode());
 746         // assertEquals("Check response code after deActive user", 200,
 747         // deActivateUserResponse.getErrorCode().intValue());
 748         //
 749         // UserRestUtils.validateUserDetailsOnResponse(sdncUserDetails,
 750         // deActivateUserResponse.getResponse());
 751         // UserRestUtils.validateDeleteUserAuditMessage(sdncUserDetails,
 752         // sdncAdminUser, "200", UserResponseMessageEnum.SUCCESS_MESSAGE.getValue(),
 753         // UserRestUtils.getAddUserAuditMessage("DeleteUser"));
 754         //
 755
 756 }