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