2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
21 package org.openecomp.sdc.ci.tests.execute.user;
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;
28 import java.util.ArrayList;
29 import java.util.Arrays;
30 import java.util.HashMap;
31 import java.util.List;
33 import java.util.Map.Entry;
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;
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;
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;
90 sdncAdminUser = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
95 public static TestName name = new TestName();
97 public ActivateDeActivateDeleteUser() {
98 super(name, ActivateDeActivateDeleteUser.class.getName());
102 public void authorizeDeActivatedUser() throws Exception {
104 User sdncUserDetails = getDefaultUserDetails();
108 UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
109 DbUtils.cleanAllAudits();
111 RestResponse createUserResponse = UserRestUtils.createUser(sdncUserDetails, sdncAdminUser);
112 validateSuccessCreateUserResponse(sdncUserDetails, createUserResponse);
114 // deActivate created user
115 RestResponse deActivateUserResponse = UserRestUtils.deActivateUser(sdncUserDetails, sdncAdminUser);
116 sdncUserDetails.setStatus(UserStatusEnum.INACTIVE);
117 validateSuccessDeActivateUserResponse(sdncUserDetails, deActivateUserResponse);
119 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.USER_INACTIVE.name());
120 RestResponse getUserResponse = UserRestUtils.getUser(sdncUserDetails, sdncAdminUser);
122 AssertJUnit.assertEquals("Check response code after deActive user", errorInfo.getCode(),
123 getUserResponse.getErrorCode());
125 List<String> variables = Arrays.asList(sdncUserDetails.getUserId());
126 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.USER_INACTIVE.name(), variables,
127 getUserResponse.getResponse());
129 // clean audit before authorization test
130 DbUtils.cleanAllAudits();
132 // Perform login from WebSeal
133 User sealUserDetails = sdncUserDetails;
134 RestResponse authorizedUserResponse = UserRestUtils.authorizedUserTowardsCatalogBeQA(sealUserDetails);
138 ErrorInfo errorInfo2 = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_ACCESS.name());
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());
146 List<String> variables2 = Arrays.asList();
147 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_ACCESS.name(), variables2,
148 authorizedUserResponse.getResponse());
150 // validate against ES DB
152 UserValidationUtils.validateDataAgainstAuditDB_access(sealUserDetails,
153 DbUtils.parseAuditRespByAction("Access"), authorizedUserResponse, errorInfo2, variables2);
156 UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
161 public User getDefaultUserDetails() {
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);
170 return sdncUserDetails;
173 public void validateSuccessCreateUserResponse(User sdncUserDetails, RestResponse createUserResponse)
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());
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);
192 RestResponse getUserResponse = UserRestUtils.getUser(sdncUserDetails, sdncAdminUser);
193 UserValidationUtils.validateUserDetailsOnResponse(sdncUserDetails, getUserResponse.getResponse());
197 public void validateSuccessDeActivateUserResponse(User sdncUserDetails, RestResponse deActivateUserResponse)
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());
206 UserValidationUtils.validateUserDetailsOnResponse(sdncUserDetails, deActivateUserResponse.getResponse());
208 String deleteUser = "DeleteUser";
209 ExpectedUserCRUDAudit constructFieldsForAuditValidation = Convertor
210 .constructFieldsForAuditValidation(deleteUser, sdncAdminUser, ActionStatus.OK, null, sdncUserDetails);
211 AuditValidationUtils.validateAddUserAudit(constructFieldsForAuditValidation, deleteUser);
215 // US498322 - Add Status Field to USER
218 public void createNewUser() throws Exception {
220 User sdncUserDetails = getDefaultUserDetails();
223 UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
224 DbUtils.cleanAllAudits();
226 RestResponse createUserResponse = UserRestUtils.createUser(sdncUserDetails, sdncAdminUser);
227 validateSuccessCreateUserResponse(sdncUserDetails, createUserResponse);
230 UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
236 public void createDefaultUser() throws Exception {
238 User sdncUserDetails = getDefaultUserDetails();
239 sdncUserDetails.setFirstName(null);
240 sdncUserDetails.setLastName(null);
241 sdncUserDetails.setEmail(null);
242 sdncUserDetails.setRole(null);
246 UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
247 DbUtils.cleanAllAudits();
249 RestResponse createUserResponse = UserRestUtils.createUser(sdncUserDetails, sdncAdminUser);
250 validateSuccessCreateUserResponse(sdncUserDetails, createUserResponse);
253 UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
259 public void createTesterUser() throws Exception {
261 User sdncUserDetails = getDefaultUserDetails();
262 sdncUserDetails.setLastName(null);
263 sdncUserDetails.setRole(UserRoleEnum.TESTER.name());
267 UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
268 DbUtils.cleanAllAudits();
270 RestResponse createUserResponse = UserRestUtils.createUser(sdncUserDetails, sdncAdminUser);
271 validateSuccessCreateUserResponse(sdncUserDetails, createUserResponse);
274 UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
280 public void deActivateCreatedAdminUser() throws Exception {
282 User sdncUserDetails = getDefaultUserDetails();
286 UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
287 DbUtils.cleanAllAudits();
289 RestResponse createUserResponse = UserRestUtils.createUser(sdncUserDetails, sdncAdminUser);
290 validateSuccessCreateUserResponse(sdncUserDetails, createUserResponse);
292 // deActivate created user
293 RestResponse deActivateUserResponse = UserRestUtils.deActivateUser(sdncUserDetails, sdncAdminUser);
294 sdncUserDetails.setStatus(UserStatusEnum.INACTIVE);
295 validateSuccessDeActivateUserResponse(sdncUserDetails, deActivateUserResponse);
297 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.USER_INACTIVE.name());
299 RestResponse getUserResponse = UserRestUtils.getUser(sdncUserDetails, sdncAdminUser);
301 assertEquals("Check response code after get user", errorInfo.getCode(), getUserResponse.getErrorCode());
303 List<String> variables = Arrays.asList(sdncUserDetails.getUserId());
304 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.USER_INACTIVE.name(), variables,
305 getUserResponse.getResponse());
308 UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
314 public void deActivateTheSameUserTwice() throws Exception {
316 User sdncUserDetails = getDefaultUserDetails();
320 UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
321 DbUtils.cleanAllAudits();
323 RestResponse createUserResponse = UserRestUtils.createUser(sdncUserDetails, sdncAdminUser);
324 validateSuccessCreateUserResponse(sdncUserDetails, createUserResponse);
326 // deActivate created user
327 RestResponse deActivateUserResponse = UserRestUtils.deActivateUser(sdncUserDetails, sdncAdminUser);
328 sdncUserDetails.setStatus(UserStatusEnum.INACTIVE);
329 validateSuccessDeActivateUserResponse(sdncUserDetails, deActivateUserResponse);
331 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.USER_INACTIVE.name());
333 RestResponse getUserResponse = UserRestUtils.getUser(sdncUserDetails, sdncAdminUser);
335 assertEquals("Check response code after deActive user", errorInfo.getCode(),
336 getUserResponse.getErrorCode());
338 List<String> variables = Arrays.asList(sdncUserDetails.getUserId());
339 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.USER_INACTIVE.name(), variables,
340 getUserResponse.getResponse());
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());
348 List<String> variables2 = Arrays.asList(sdncUserDetails.getUserId());
349 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.USER_INACTIVE.name(), variables2,
350 deActivateUserResponse2.getResponse());
353 UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
359 public void createAgainDeActivatedUser() throws Exception {
361 User sdncUserDetails = getDefaultUserDetails();
365 UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
366 DbUtils.cleanAllAudits();
368 RestResponse createUserResponse = UserRestUtils.createUser(sdncUserDetails, sdncAdminUser);
369 validateSuccessCreateUserResponse(sdncUserDetails, createUserResponse);
371 // deActivate created user
372 RestResponse deActivateUserResponse = UserRestUtils.deActivateUser(sdncUserDetails, sdncAdminUser);
373 sdncUserDetails.setStatus(UserStatusEnum.INACTIVE);
374 validateSuccessDeActivateUserResponse(sdncUserDetails, deActivateUserResponse);
376 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.USER_INACTIVE.name());
377 RestResponse getUserResponse = UserRestUtils.getUser(sdncUserDetails, sdncAdminUser);
379 assertEquals("Check response code after deActive user", errorInfo.getCode(),
380 getUserResponse.getErrorCode());
382 List<String> variables = Arrays.asList(sdncUserDetails.getUserId());
383 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.USER_INACTIVE.name(), variables,
384 getUserResponse.getResponse());
386 // create the user with the same UserId(details) as deActivated user
387 DbUtils.cleanAllAudits();
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());
394 List<String> variables2 = Arrays.asList(sdncUserDetails.getUserId());
395 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.USER_INACTIVE.name(), variables2,
396 createUserResponse2.getResponse());
399 UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
404 // very not recommend to run this test, resources/services may be zombie
406 public void deActivateLastAdminUser() throws Exception {
410 // send get all ADMIN user request toward BE
411 RestResponse getAllAdminUsers = UserRestUtils.getAllAdminUsers(sdncAdminUser);
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());
417 TypeToken<List<User>> typeToken = new TypeToken<List<User>>() {
419 List<User> listOfUsersOnResponse = gson.fromJson(getAllAdminUsers.getResponse(), typeToken.getType());
420 logger.debug("listOfUsers: {}", listOfUsersOnResponse);
422 // build map of all Admin users from listOfUsersOnResponse from
424 Map<String, User> mapAllUsersOnResponse = new HashMap<String, User>();
425 for (User sdncUser : listOfUsersOnResponse) {
426 mapAllUsersOnResponse.put(sdncUser.getUserId(), sdncUser);
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);
433 // deActivate all Admin users from the UserIdAllAdminList list
434 for (Entry<String, User> entry : mapAllUsersOnResponse.entrySet()) {
435 UserRestUtils.deActivateUser(entry.getValue(), sdncAdminUser);
438 // deActivate last Admin user user
439 RestResponse deActivateUserResponse = UserRestUtils.deActivateUser(sdncAdminUser, sdncAdminUser);
441 ErrorInfo errorInfo = ErrorValidationUtils
442 .parseErrorConfigYaml(ActionStatus.DELETE_USER_ADMIN_CONFLICT.name());
444 assertEquals("Check response code after deActive user", errorInfo.getCode(),
445 deActivateUserResponse.getErrorCode());
447 List<String> variables = Arrays.asList();
448 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.DELETE_USER_ADMIN_CONFLICT.name(), variables,
449 deActivateUserResponse.getResponse());
452 // UserRestUtils.deleteUser(UserRestUtils.getAdminDetails2(),
454 // UserRestUtils.deleteUser(UserRestUtils.getAdminDetails3(),
456 // UserRestUtils.createUser(UserRestUtils.getAdminDetails2(),
458 // UserRestUtils.createUser(UserRestUtils.getAdminDetails3(),
464 // test check the resource accessibility via catalog view, resource was
465 // created by user which was deActivated
468 public void resourceAccessibility() throws Exception {
470 User sdncUserDetails = getDefaultUserDetails();
471 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource("tosca.nodes.newresource4test4",
472 NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_INFRASTRUCTURE, "jh0003");
473 String resourceBaseVersion = "0.1";
477 // resourceUtils.deleteResource_allVersions(resourceDetails,
479 UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
481 DbUtils.cleanAllAudits();
482 RestResponse createUserResponse = UserRestUtils.createUser(sdncUserDetails, sdncAdminUser);
483 validateSuccessCreateUserResponse(sdncUserDetails, createUserResponse);
485 // ------------------------Start create
486 // resource---------------------------------------------------------------------------------
489 RestResponse createResponse = ResourceRestUtils.createResource(resourceDetails, sdncUserDetails);
490 assertEquals("Check response code after create", 201, createResponse.getErrorCode().intValue());
492 Resource createdResource = ResponseParser.convertResourceResponseToJavaObject(createResponse.getResponse());
494 RestResponse resourceGetResponse = ResourceRestUtils.getResource(sdncUserDetails,
495 createdResource.getUniqueId());
496 assertEquals("Check response code after get", 200, resourceGetResponse.getErrorCode().intValue());
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());
506 resourceRespJavaObject
507 .setCreatorFullName(sdncUserDetails.getFirstName() + " " + sdncUserDetails.getLastName());
508 resourceRespJavaObject
509 .setLastUpdaterFullName(sdncUserDetails.getFirstName() + " " + sdncUserDetails.getLastName());
511 ResourceValidationUtils.validateResp(resourceGetResponse, resourceRespJavaObject);
513 // ------------------------End create
514 // resource---------------------------------------------------------------------------------
516 // clean audit before authorization test
517 DbUtils.cleanAllAudits();
519 // deActivate created user
520 RestResponse deActivateUserResponse = UserRestUtils.deActivateUser(sdncUserDetails, sdncAdminUser);
521 sdncUserDetails.setStatus(UserStatusEnum.INACTIVE);
522 validateSuccessDeActivateUserResponse(sdncUserDetails, deActivateUserResponse);
524 UserValidationUtils.validateDeleteUserAuditMessage(sdncUserDetails, sdncAdminUser, "200",
525 UserResponseMessageEnum.SUCCESS_MESSAGE.getValue(),
526 UserValidationUtils.getAddUserAuditMessage("DeleteUser"));
528 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.USER_INACTIVE.name());
529 RestResponse getUserResponse = UserRestUtils.getUser(sdncUserDetails, sdncAdminUser);
531 assertEquals("Check response code after deActive user", errorInfo.getCode(),
532 getUserResponse.getErrorCode());
534 List<String> variables = Arrays.asList(sdncUserDetails.getUserId());
535 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.USER_INACTIVE.name(), variables,
536 getUserResponse.getResponse());
538 // checking if created resource is accessible
539 DbUtils.cleanAllAudits();
541 RestResponse getCatalogDataResponse = CatalogRestUtils.getCatalog(sdncAdminUser.getUserId());
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());
551 // expected resource list
552 List<String> resourceExpectedUniqIdList = new ArrayList<String>();
553 resourceExpectedUniqIdList.add(resourceDetails.getUniqueId());
554 logger.debug("resourceExpectedUniqIdList: {}", resourceExpectedUniqIdList);
556 compareResourceUniqIdList(getCatalogDataResponse.getResponse(), resourceExpectedUniqIdList, true);
559 // resourceUtils.deleteResource_allVersions(resourceDetails,
561 UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
566 // test check the resource accessibility via catalog view, resource was
567 // created by user which was deActivated
570 public void resourceAccessibilityOnImport() throws Exception {
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";
581 // resourceUtils.deleteResource_allVersions(resourceDetails,
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);
590 // ------------------------Start import
591 // resource---------------------------------------------------------------------------------
593 // import new resource with CERTIFIED state
594 User importer = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN4);
595 RestResponse importResponse = ImportRestUtils.importResourceByName(resourceDetails, importer);
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());
601 // ------------------------End import
602 // resource---------------------------------------------------------------------------------
604 // clean audit before authorization test
605 DbUtils.cleanAllAudits();
607 // deActivate created user
608 RestResponse deActivateUserResponse = UserRestUtils.deActivateUser(sdncUserDetails, sdncAdminUser);
609 sdncUserDetails.setStatus(UserStatusEnum.INACTIVE);
610 validateSuccessDeActivateUserResponse(sdncUserDetails, deActivateUserResponse);
612 UserValidationUtils.validateDeleteUserAuditMessage(sdncUserDetails, sdncAdminUser, "200",
613 UserResponseMessageEnum.SUCCESS_MESSAGE.getValue(),
614 UserValidationUtils.getAddUserAuditMessage("DeleteUser"));
616 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.USER_INACTIVE.name());
617 RestResponse getUserResponse = UserRestUtils.getUser(sdncUserDetails, sdncAdminUser);
619 assertEquals("Check response code after deActive user", errorInfo.getCode(),
620 getUserResponse.getErrorCode());
622 List<String> variables = Arrays.asList(sdncUserDetails.getUserId());
623 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.USER_INACTIVE.name(), variables,
624 getUserResponse.getResponse());
626 // checking if created resource is accessible
627 DbUtils.cleanAllAudits();
629 RestResponse getCatalogDataResponse = CatalogRestUtils.getCatalog(sdncAdminUser.getUserId());
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());
639 // expected resource list
640 List<String> resourceExpectedUniqIdList = new ArrayList<String>();
641 resourceExpectedUniqIdList.add(resourceDetails.getUniqueId());
642 logger.debug("resourceExpectedUniqIdList: {}", resourceExpectedUniqIdList);
644 compareResourceUniqIdList(getCatalogDataResponse.getResponse(), resourceExpectedUniqIdList, true);
647 // resourceUtils.deleteResource_allVersions(resourceDetails,
649 UserRestUtils.deleteUser(sdncUserDetails, sdncAdminUser, true);
654 public void compareServiceUniqIdList(String response, List<String> expectedList, boolean flag) {
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());
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);
671 public void compareResourceUniqIdList(String response, List<String> expectedList, boolean flag) {
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());
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);
687 logger.debug("ResourceReqDetails list on response: {}",resourceReqDetailsListOnResponse);
689 List<String> resourceActualUniqIdList = new ArrayList<String>();
690 for (ResourceReqDetails resource : resourceReqDetailsListOnResponse) {
691 resourceActualUniqIdList.add(resource.getUniqueId());
693 logger.debug("resourceActualUniqIdList on response: {}",resourceActualUniqIdList);
694 logger.debug("resourceExpectedUniqIdList on response: {}",expectedList);
697 assertTrue("actual list does not contain expected list",
698 resourceActualUniqIdList.containsAll(expectedList));
700 assertFalse("actual list contains non expected list elements",
701 resourceActualUniqIdList.containsAll(expectedList));
705 // public User getDefaultUserDetails(){
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);
713 // return sdncUserDetails;
716 // public void validateSuccessCreateUserResponse(User sdncUserDetails,
717 // RestResponse createUserResponse) throws Exception{
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());
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,
734 // UserRestUtils.validateUserDetailsOnResponse(sdncUserDetails,
735 // getUserResponse.getResponse());
739 // public void validateSuccessDeActivateUserResponse(User sdncUserDetails,
740 // RestResponse deActivateUserResponse) throws Exception{
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());
749 // UserRestUtils.validateUserDetailsOnResponse(sdncUserDetails,
750 // deActivateUserResponse.getResponse());
751 // UserRestUtils.validateDeleteUserAuditMessage(sdncUserDetails,
752 // sdncAdminUser, "200", UserResponseMessageEnum.SUCCESS_MESSAGE.getValue(),
753 // UserRestUtils.getAddUserAuditMessage("DeleteUser"));