gerrit.onap Code Review - sdc.git/blob

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