catalog-be/src/test/java/org/openecomp/sdc/be/user/UserBusinessLogicTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2019 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.be.user;
  22
  23 import static org.assertj.core.api.Assertions.assertThat;
  24 import static org.junit.Assert.assertEquals;
  25 import static org.junit.Assert.assertTrue;
  26 import static org.mockito.ArgumentMatchers.any;
  27 import static org.mockito.ArgumentMatchers.anyString;
  28 import static org.mockito.ArgumentMatchers.eq;
  29 import static org.mockito.Mockito.doThrow;
  30 import static org.mockito.Mockito.never;
  31 import static org.mockito.Mockito.verify;
  32 import static org.mockito.Mockito.when;
  33
  34 import com.google.common.collect.Lists;
  35 import fj.data.Either;
  36 import java.util.ArrayList;
  37 import java.util.HashMap;
  38 import java.util.HashSet;
  39 import java.util.LinkedList;
  40 import java.util.List;
  41 import java.util.Set;
  42 import org.apache.commons.lang3.StringUtils;
  43 import org.apache.tinkerpop.gremlin.structure.Edge;
  44 import org.apache.tinkerpop.gremlin.structure.util.detached.DetachedEdge;
  45 import org.javatuples.Pair;
  46 import org.junit.Before;
  47 import org.junit.Test;
  48 import org.junit.runner.RunWith;
  49 import org.mockito.InjectMocks;
  50 import org.mockito.Mock;
  51 import org.mockito.Mockito;
  52 import org.mockito.junit.MockitoJUnitRunner;
  53 import org.openecomp.sdc.be.components.impl.ResponseFormatManager;
  54 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
  55 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
  56 import org.openecomp.sdc.be.config.ConfigurationManager;
  57 import org.openecomp.sdc.be.dao.api.ActionStatus;
  58 import org.openecomp.sdc.be.dao.utils.UserStatusEnum;
  59 import org.openecomp.sdc.be.facade.operations.UserOperation;
  60 import org.openecomp.sdc.be.impl.ComponentsUtils;
  61 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  62 import org.openecomp.sdc.be.model.User;
  63 import org.openecomp.sdc.be.model.operations.StorageException;
  64 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  65 import org.openecomp.sdc.be.model.operations.impl.UserAdminOperation;
  66 import org.openecomp.sdc.common.api.UserRoleEnum;
  67 import org.openecomp.sdc.common.datastructure.UserContext;
  68 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  69 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  70 import org.openecomp.sdc.common.util.ThreadLocalsHolder;
  71
  72 @RunWith(MockitoJUnitRunner.class)
  73 public class UserBusinessLogicTest {
  74
  75     private static final String MOCK_MAIL = "mock@mock.mock";
  76     private static final String MOCK_MODIFIER = "mockModif";
  77     private static final String MOCK_NEW_USER = "mockNewUs";
  78     @Mock
  79     private UserAdminOperation userAdminOperation;
  80     @Mock
  81     private ComponentsUtils componentsUtils;
  82     @Mock
  83     private UserOperation facadeUserOperation;
  84     @Mock
  85     private User user;
  86     @Mock
  87     private User userNull;
  88     @InjectMocks
  89     private UserBusinessLogic testSubject;
  90
  91     static ResponseFormatManager responseFormatManager = new ResponseFormatManager();
  92
  93     @Before
  94     public void setUp() {
  95         new ConfigurationManager(new FSConfigurationSource(ExternalConfiguration.getChangeListener(), "src/test/resources/config/catalog-be"));
  96         doThrow(new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR)).when(componentsUtils)
  97             .auditAdminUserActionAndThrowException(any(), any(), any(), any(), any(), any());
  98     }
  99
 100     @Test(expected = ComponentException.class)
 101     public void testCreateUserErrorGetUser() {
 102         User newUser = new User();
 103         when(userAdminOperation.getUserData(Mockito.anyString(), Mockito.anyBoolean())).thenReturn(Either.right(ActionStatus.USER_NOT_FOUND));
 104         // default test
 105         testSubject.createUser("mock", newUser);
 106
 107         verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
 108     }
 109
 110     @Test(expected = ComponentException.class)
 111     public void testGetUserContextNull() {
 112         ThreadLocalsHolder.setUserContext(null);
 113         testSubject.getUser("userId");
 114     }
 115
 116     @Test(expected = ComponentException.class)
 117     public void testGetUserContextIdEmpty() {
 118         UserContext userContext = new UserContext(null);
 119         ThreadLocalsHolder.setUserContext(userContext);
 120
 121         testSubject.getUser(null);
 122     }
 123
 124     @Test
 125     public void testGetUserContext() {
 126         UserContext originalUserContext = ThreadLocalsHolder.getUserContext();
 127         String userId = "userId";
 128         Set<String> userRoles = new HashSet<>();
 129         userRoles.add(Role.DESIGNER.name());
 130         UserContext userContext = new UserContext(userId, userRoles, "test", "User");
 131
 132         User user = new User();
 133         user.setUserId(userId);
 134         user.setRole(Role.DESIGNER.name());
 135         user.setStatus(UserStatusEnum.ACTIVE);
 136         user.setFirstName("test");
 137         user.setLastName("User");
 138
 139         getAndValidateUser(originalUserContext, userId, userContext, user);
 140     }
 141
 142     private void getAndValidateUser(UserContext originalUserContext, String userId, UserContext userContext, User user) {
 143         try {
 144             ThreadLocalsHolder.setUserContext(userContext);
 145             User convertedUser = testSubject.getUser(userId);
 146             assertThat(convertedUser).isEqualTo(user);
 147         } finally {
 148             ThreadLocalsHolder.setUserContext(originalUserContext);
 149         }
 150     }
 151
 152     @Test
 153     public void testGetUserContextInActive() {
 154         UserContext originalUserContext = ThreadLocalsHolder.getUserContext();
 155         String userId = "userId";
 156         //Set<String> userRoles = new HashSet<>();
 157         //userRoles.add(Role.DESIGNER.name());
 158         UserContext userContext = new UserContext(userId, null, "test", "User");
 159
 160         User user = new User();
 161         user.setUserId(userId);
 162         user.setRole(null);
 163         user.setStatus(UserStatusEnum.INACTIVE);
 164         user.setFirstName("test");
 165         user.setLastName("User");
 166
 167         getAndValidateUser(originalUserContext, userId, userContext, user);
 168     }
 169
 170     @Test(expected = ComponentException.class)
 171     public void testCreateUserErrorUserNotAdmin() {
 172         User newUser = new User();
 173         User userFromDb = new User();
 174         userFromDb.setRole(UserRoleEnum.DESIGNER.getName());
 175         when(userAdminOperation.getUserData(Mockito.anyString(), Mockito.anyBoolean())).thenReturn(Either.left(userFromDb));
 176         testSubject.createUser("mock", newUser);
 177
 178         verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
 179     }
 180
 181     @Test(expected = ComponentException.class)
 182     public void testCreateErrorCheckingNewUser() {
 183         User newUser = new User(MOCK_NEW_USER);
 184         User modifierFromDb = new User(MOCK_MODIFIER);
 185         modifierFromDb.setRole(UserRoleEnum.ADMIN.getName());
 186         when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.left(modifierFromDb));
 187         when(userAdminOperation.getUserData(MOCK_NEW_USER, false)).thenReturn(Either.right(ActionStatus.AUTH_REQUIRED));
 188
 189         // default test
 190         testSubject.createUser(MOCK_MODIFIER, newUser);
 191
 192         verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
 193     }
 194
 195     @Test(expected = ComponentException.class)
 196     public void testCreateErrorCheckingNewUser2() {
 197         User newUser = new User(MOCK_NEW_USER);
 198         User modifierFromDb = new User(MOCK_MODIFIER);
 199         modifierFromDb.setRole(UserRoleEnum.ADMIN.getName());
 200         when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.left(modifierFromDb));
 201         when(userAdminOperation.getUserData(MOCK_NEW_USER, false)).thenReturn(Either.right(ActionStatus.USER_ALREADY_EXIST));
 202
 203         // default test
 204         testSubject.createUser(MOCK_MODIFIER, newUser);
 205
 206         verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
 207     }
 208
 209     @Test(expected = ComponentException.class)
 210     public void testCreate_userExists_fails() {
 211         User newUser = new User(MOCK_NEW_USER);
 212         User modifierFromDb = new User(MOCK_MODIFIER);
 213         modifierFromDb.setRole(UserRoleEnum.ADMIN.getName());
 214         User userFromDb2 = new User();
 215         when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.left(modifierFromDb));
 216         when(userAdminOperation.getUserData(MOCK_NEW_USER, false)).thenReturn(Either.left(userFromDb2));
 217         testSubject.createUser(MOCK_MODIFIER, newUser);
 218
 219         verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
 220     }
 221
 222     @Test(expected = ComponentException.class)
 223     public void testCreateInvalidMail() {
 224         User newUser = new User(MOCK_NEW_USER);
 225         newUser.setEmail("mock");
 226
 227         User userFromDbAdmin = new User(MOCK_MODIFIER);
 228         userFromDbAdmin.setRole(UserRoleEnum.ADMIN.getName());
 229
 230         User userFromDbNew = new User();
 231         userFromDbNew.setStatus(UserStatusEnum.INACTIVE);
 232         when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.left(userFromDbAdmin));
 233         when(userAdminOperation.getUserData(MOCK_NEW_USER, false)).thenReturn(Either.left(userFromDbNew));
 234         testSubject.createUser(MOCK_MODIFIER, newUser);
 235
 236         verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
 237     }
 238
 239     @Test(expected = ComponentException.class)
 240     public void testCreateInvalidRole() {
 241         User newUser = new User(MOCK_NEW_USER);
 242         newUser.setEmail(MOCK_MAIL);
 243         newUser.setRole("mock");
 244
 245         User userFromDbAdmin = new User(MOCK_MODIFIER);
 246         userFromDbAdmin.setRole(UserRoleEnum.ADMIN.getName());
 247         User userFromDbNew = new User();
 248         userFromDbNew.setStatus(UserStatusEnum.INACTIVE);
 249         when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.left(userFromDbAdmin));
 250         when(userAdminOperation.getUserData(MOCK_NEW_USER, false)).thenReturn(Either.left(userFromDbNew));
 251         testSubject.createUser(MOCK_MODIFIER, newUser);
 252
 253         verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
 254     }
 255
 256     @Test
 257     public void testCreateValidUser() throws Exception {
 258         User newUser = new User();
 259         newUser.setUserId(MOCK_NEW_USER);
 260         newUser.setEmail(MOCK_MAIL);
 261         newUser.setRole(UserRoleEnum.DESIGNER.name());
 262
 263         User userFromDbAdmin = new User();
 264         userFromDbAdmin.setUserId(MOCK_MODIFIER);
 265         userFromDbAdmin.setRole(UserRoleEnum.ADMIN.getName());
 266         Either<User, ActionStatus> value = Either.left(userFromDbAdmin);
 267
 268         User userFromDbNew = new User();
 269         userFromDbNew.setStatus(UserStatusEnum.INACTIVE);
 270         Either<User, ActionStatus> value2 = Either.right(ActionStatus.USER_NOT_FOUND);
 271         when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(value);
 272         when(userAdminOperation.getUserData(MOCK_NEW_USER, false)).thenReturn(value2);
 273         when(userAdminOperation.saveUserData(newUser)).thenReturn(newUser);
 274
 275         // test
 276         User resultUser = testSubject.createUser(MOCK_MODIFIER, newUser);
 277         assertThat(resultUser).isEqualTo(newUser);
 278
 279         verify(facadeUserOperation).updateUserCache(UserOperationEnum.CREATE, newUser.getUserId(), newUser.getRole());
 280     }
 281
 282     @Test(expected = ComponentException.class)
 283     public void testUpdateUserRoleNotFound() {
 284         User modifier = new User(MOCK_MODIFIER);
 285         String userIdToUpdate = "";
 286         String userRole = "";
 287
 288         when(userAdminOperation.getUserData(modifier.getUserId(), false)).thenReturn(Either.right(ActionStatus.USER_NOT_FOUND));
 289         testSubject.updateUserRole(MOCK_MODIFIER, userIdToUpdate, userRole);
 290
 291         verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
 292     }
 293
 294     @Test(expected = ComponentException.class)
 295     public void testUpdateUserRoleModifierWrongRole() {
 296         User modifier = new User(MOCK_MODIFIER);
 297         modifier.setRole(UserRoleEnum.DESIGNER.getName());
 298         String userIdToUpdate = "";
 299         String userRole = "";
 300
 301         when(userAdminOperation.getUserData(modifier.getUserId(), false)).thenReturn(Either.left(modifier));
 302         testSubject.updateUserRole(MOCK_MODIFIER, userIdToUpdate, userRole);
 303
 304         verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
 305     }
 306
 307     @Test(expected = ComponentException.class)
 308     public void testUpdateUserRoleSameId() {
 309         User modifier = new User(MOCK_MODIFIER);
 310         modifier.setRole(UserRoleEnum.ADMIN.getName());
 311         String userRole = "";
 312
 313         when(userAdminOperation.getUserData(modifier.getUserId(), false)).thenReturn(Either.left(modifier));
 314         testSubject.updateUserRole(MOCK_MODIFIER, MOCK_MODIFIER, userRole);
 315
 316         verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
 317     }
 318
 319     @Test(expected = ComponentException.class)
 320     public void testUpdateUserRoleUpdatedNotFound() {
 321         User modifier = new User(MOCK_MODIFIER);
 322         modifier.setRole(UserRoleEnum.ADMIN.getName());
 323         String userIdToUpdate = "mock1";
 324         String userRole = "";
 325
 326         when(userAdminOperation.getUserData(modifier.getUserId(), false)).thenReturn(Either.left(modifier));
 327         when(userAdminOperation.getUserData(userIdToUpdate, false)).thenReturn(Either.right(ActionStatus.ECOMP_USER_NOT_FOUND));
 328
 329         testSubject.updateUserRole(MOCK_MODIFIER, userIdToUpdate, userRole);
 330
 331         verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
 332     }
 333
 334     @Test(expected = ComponentException.class)
 335     public void testUpdateUserRoleUpdatedToInvalidRole() {
 336         User modifier = new User(MOCK_MODIFIER);
 337         modifier.setRole(UserRoleEnum.ADMIN.getName());
 338         String userIdToUpdate = "mock1";
 339         String userRole = "";
 340
 341         when(userAdminOperation.getUserData(modifier.getUserId(), false)).thenReturn(Either.left(modifier));
 342         when(userAdminOperation.getUserData(userIdToUpdate, false)).thenReturn(Either.left(modifier));
 343
 344         testSubject.updateUserRole(MOCK_MODIFIER, userIdToUpdate, userRole);
 345
 346         verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
 347     }
 348
 349     @Test(expected = StorageException.class)
 350     public void testUpdateUserRolePendingTaskFetchFailed() {
 351         User modifier = new User(MOCK_MODIFIER);
 352         modifier.setRole(UserRoleEnum.ADMIN.getName());
 353         String userIdToUpdate = "mock1";
 354         String userRole = UserRoleEnum.DESIGNER.getName();
 355
 356         User updatedUser = new User();
 357         updatedUser.setUserId(userIdToUpdate);
 358         updatedUser.setRole(UserRoleEnum.TESTER.getName());
 359
 360         when(userAdminOperation.getUserData(modifier.getUserId(), false)).thenReturn(Either.left(modifier));
 361         when(userAdminOperation.getUserData(userIdToUpdate, false)).thenReturn(Either.left(updatedUser));
 362         when(userAdminOperation.getUserPendingTasksList(Mockito.any(), Mockito.any()))
 363             .thenThrow(new StorageException(StorageOperationStatus.INCONSISTENCY));
 364
 365         // default test
 366         testSubject.updateUserRole(MOCK_MODIFIER, userIdToUpdate, userRole);
 367
 368         verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
 369     }
 370
 371     @Test
 372     public void testUpdateTesterRole_taskStateCriteriaShouldBeEmpty_shouldSucceed() {
 373         User modifier = new User(MOCK_MODIFIER);
 374         modifier.setRole(UserRoleEnum.ADMIN.getName());
 375         String userIdToUpdate = "mock1";
 376         String userRole = UserRoleEnum.DESIGNER.getName();
 377
 378         User updatedUser = new User(userIdToUpdate);
 379         updatedUser.setRole(UserRoleEnum.TESTER.getName());
 380
 381         User newUser = new User();
 382         newUser.setUserId(userIdToUpdate);
 383         newUser.setRole(UserRoleEnum.DESIGNER.getName());
 384         List<Object> testerState = new ArrayList<>();
 385         when(userAdminOperation.getUserData(modifier.getUserId(), false)).thenReturn(Either.left(modifier));
 386         when(userAdminOperation.getUserData(userIdToUpdate, false)).thenReturn(Either.left(updatedUser));
 387         when(userAdminOperation.getUserPendingTasksList(eq(updatedUser), eq(testerState))).thenReturn(new LinkedList<>());
 388         when(userAdminOperation.updateUserData(newUser)).thenReturn(updatedUser);
 389
 390         // default test
 391         User user = testSubject.updateUserRole(MOCK_MODIFIER, userIdToUpdate, userRole);
 392         assertThat(user).isEqualToComparingFieldByField(updatedUser);
 393
 394         verify(facadeUserOperation).updateUserCache(UserOperationEnum.CHANGE_ROLE, userIdToUpdate, UserRoleEnum.TESTER.name());
 395     }
 396
 397     @Test(expected = ComponentException.class)
 398     public void testUpdateDesignerRoleListOfTasksNotEmpty_shouldFail() {
 399         User modifier = new User(MOCK_MODIFIER);
 400         modifier.setRole(UserRoleEnum.ADMIN.getName());
 401         String userIdToUpdate = "mock1";
 402         String userRole = UserRoleEnum.TESTER.getName();
 403
 404         User updatedUser = new User();
 405         updatedUser.setUserId(userIdToUpdate);
 406         updatedUser.setRole(UserRoleEnum.DESIGNER.getName());
 407
 408         List<Object> designerState = new ArrayList<>();
 409         designerState.add(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name());
 410
 411         when(userAdminOperation.getUserData(modifier.getUserId(), false)).thenReturn(Either.left(modifier));
 412         when(userAdminOperation.getUserData(userIdToUpdate, false)).thenReturn(Either.left(updatedUser));
 413         List<Edge> list = new LinkedList<>();
 414         list.add(new DetachedEdge("sdas", "fdfs", new HashMap<>(), Pair.with("sadas", "sadasd"), "",
 415             Pair.with("sadas", "sadasd"), ""));
 416         testSubject.updateUserRole(MOCK_MODIFIER, userIdToUpdate, userRole);
 417
 418         verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
 419     }
 420
 421     @Test(expected = StorageException.class)
 422     public void testUpdateUserRoleStorageError_shouldFail() {
 423         User modifier = new User(MOCK_MODIFIER);
 424         modifier.setRole(UserRoleEnum.ADMIN.getName());
 425         String userIdToUpdate = "mock1";
 426         String userRole = UserRoleEnum.DESIGNER.getName();
 427
 428         User updatedUser = new User(userIdToUpdate);
 429         updatedUser.setRole(UserRoleEnum.TESTER.getName());
 430
 431         when(userAdminOperation.getUserData(modifier.getUserId(), false)).thenReturn(Either.left(modifier));
 432         when(userAdminOperation.getUserData(userIdToUpdate, false)).thenReturn(Either.left(updatedUser));
 433         when(userAdminOperation.getUserPendingTasksList(Mockito.any(), Mockito.any())).thenReturn(new LinkedList<>());
 434         when(userAdminOperation.updateUserData(Mockito.any())).thenThrow(new StorageException(StorageOperationStatus.INCONSISTENCY));
 435         // default test
 436         testSubject.updateUserRole(MOCK_MODIFIER, userIdToUpdate, userRole);
 437
 438         verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
 439     }
 440
 441     @Test
 442     public void testUpdateUserRoleEmptyTaskList_shouldSucceed() {
 443         User modifier = new User(MOCK_MODIFIER);
 444         modifier.setRole(UserRoleEnum.ADMIN.getName());
 445         String userIdToUpdate = "mock1";
 446         String userRole = UserRoleEnum.DESIGNER.getName();
 447
 448         User updatedUser = new User();
 449         updatedUser.setUserId(userIdToUpdate);
 450         updatedUser.setRole(UserRoleEnum.TESTER.getName());
 451
 452         when(userAdminOperation.getUserData(modifier.getUserId(), false)).thenReturn(Either.left(modifier));
 453         when(userAdminOperation.getUserData(userIdToUpdate, false)).thenReturn(Either.left(updatedUser));
 454         when(userAdminOperation.getUserPendingTasksList(Mockito.any(), Mockito.any())).thenReturn(new LinkedList<>());
 455         when(userAdminOperation.updateUserData(Mockito.any())).thenReturn(updatedUser);
 456         testSubject.updateUserRole(MOCK_MODIFIER, userIdToUpdate, userRole);
 457
 458         verify(facadeUserOperation).updateUserCache(UserOperationEnum.CHANGE_ROLE, userIdToUpdate, UserRoleEnum.TESTER.name());
 459     }
 460
 461     @Test(expected = ComponentException.class)
 462     public void testUpdateRoleToTester_shouldFail() {
 463         User modifier = new User(MOCK_MODIFIER);
 464         modifier.setRole(UserRoleEnum.ADMIN.getName());
 465         String userIdToUpdate = "mock1";
 466         String userRole = UserRoleEnum.TESTER.getName();
 467
 468         User updatedUser = new User();
 469         updatedUser.setUserId(userIdToUpdate);
 470         updatedUser.setRole(UserRoleEnum.TESTER.getName());
 471
 472         when(userAdminOperation.getUserData(modifier.getUserId(), false)).thenReturn(Either.left(modifier));
 473         when(userAdminOperation.getUserData(userIdToUpdate, false)).thenReturn(Either.left(updatedUser));
 474         testSubject.updateUserRole(MOCK_MODIFIER, userIdToUpdate, userRole);
 475     }
 476
 477     @Test
 478     public void testGetAllAdminUsers() {
 479         Either<List<User>, ActionStatus> response = Either.left(new LinkedList<>());
 480         when(userAdminOperation.getAllUsersWithRole(anyString(), Mockito.nullable(String.class)))
 481             .thenReturn(response);
 482         assertEquals(0, testSubject.getAllAdminUsers().size());
 483     }
 484
 485     @Test(expected = ComponentException.class)
 486     public void testGetAllAdminUsersFail() {
 487         Either<List<User>, ActionStatus> response = Either.right(ActionStatus.NOT_ALLOWED);
 488         when(userAdminOperation.getAllUsersWithRole(anyString(), Mockito.nullable(String.class)))
 489             .thenReturn(response);
 490         testSubject.getAllAdminUsers();
 491     }
 492
 493     @Test(expected = ComponentException.class)
 494     public void testGetUsersList1() {
 495         // test 1
 496         testSubject.getUsersList(null, null, "");
 497     }
 498
 499     @Test(expected = ComponentException.class)
 500     public void testGetUsersListFail() {
 501         String modifierAttId = "mockMod";
 502         String rolesStr = "";
 503
 504         Either<User, ActionStatus> value3 = Either.right(ActionStatus.ILLEGAL_COMPONENT_STATE);
 505         when(userAdminOperation.getUserData(modifierAttId, false)).thenReturn(value3);
 506         testSubject.getUsersList(modifierAttId, null, rolesStr);
 507     }
 508
 509     @Test(expected = ComponentException.class)
 510     public void testGetUsersListFail2() {
 511         String modifierAttId = "mockMod";
 512         String rolesStr = "";
 513
 514         Either<User, ActionStatus> value3 = Either.right(ActionStatus.USER_NOT_FOUND);
 515         when(userAdminOperation.getUserData(modifierAttId, false)).thenReturn(value3);
 516         testSubject.getUsersList(modifierAttId, null, rolesStr);
 517     }
 518
 519
 520     @Test
 521     public void testGetUsersList() {
 522         String modifierAttId = "mockMod";
 523         List<String> roles = new LinkedList<>();
 524         String rolesStr = "";
 525
 526         User a = new User();
 527         Either<User, ActionStatus> value3 = Either.left(a);
 528         when(userAdminOperation.getUserData(modifierAttId, false)).thenReturn(value3);
 529         Either<List<User>, ActionStatus> value = Either.left(new LinkedList<>());
 530         when(userAdminOperation.getAllUsersWithRole(Mockito.nullable(String.class), anyString()))
 531             .thenReturn(value);
 532
 533         assertEquals(0, testSubject.getUsersList(modifierAttId, roles, rolesStr).size());
 534     }
 535
 536     @Test(expected = ComponentException.class)
 537     public void testGetUsersListInvalidRole() {
 538         String modifierAttId = "mockMod";
 539         List<String> roles = new LinkedList<>();
 540         roles.add("mock");
 541         String rolesStr = "";
 542
 543         User a = new User();
 544         Either<User, ActionStatus> value3 = Either.left(a);
 545         when(userAdminOperation.getUserData(modifierAttId, false)).thenReturn(value3);
 546         testSubject.getUsersList(modifierAttId, roles, rolesStr);
 547     }
 548
 549     @Test(expected = ComponentException.class)
 550     public void testAuthorizeMissingId() {
 551         User authUser = new User();
 552         testSubject.authorize(authUser);
 553     }
 554
 555     @Test
 556     public void testGetUsersList2() {
 557         String modifierAttId = "mockMod";
 558         List<String> roles = new LinkedList<>();
 559         roles.add(UserRoleEnum.DESIGNER.name());
 560         String rolesStr = "";
 561
 562         User a = new User();
 563         Either<User, ActionStatus> value3 = Either.left(a);
 564         when(userAdminOperation.getUserData(modifierAttId, false)).thenReturn(value3);
 565         Either<List<User>, ActionStatus> value = Either.left(new LinkedList<>());
 566         when(userAdminOperation.getAllUsersWithRole(Mockito.nullable(String.class), anyString()))
 567             .thenReturn(value);
 568
 569         assertEquals(0, testSubject.getUsersList(modifierAttId, roles, rolesStr).size());
 570     }
 571
 572
 573     @Test(expected = ComponentException.class)
 574     public void testAuthorizeFail1() {
 575         User authUser = new User();
 576         authUser.setUserId("mockAU");
 577
 578         Either<User, ActionStatus> value = Either.right(ActionStatus.USER_NOT_FOUND);
 579         when(userAdminOperation.getUserData("mockAU", false)).thenReturn(value);
 580         testSubject.authorize(authUser);
 581     }
 582
 583     @Test(expected = ComponentException.class)
 584     public void testAuthorizeFail2() {
 585         User authUser = new User();
 586         authUser.setUserId("mockAU");
 587
 588         Either<User, ActionStatus> value = Either.right(ActionStatus.AAI_ARTIFACT_GENERATION_FAILED);
 589         when(userAdminOperation.getUserData("mockAU", false)).thenReturn(value);
 590         testSubject.authorize(authUser);
 591     }
 592
 593     @Test(expected = ComponentException.class)
 594     public void testAuthorizeFail3() {
 595         User authUser = new User();
 596         authUser.setUserId("mockAU");
 597
 598         Either<User, ActionStatus> value = Either.left(null);
 599         when(userAdminOperation.getUserData("mockAU", false)).thenReturn(value);
 600         testSubject.authorize(authUser);
 601     }
 602
 603
 604     @Test
 605     public void testAuthorize5() {
 606         User authUser = new User();
 607         authUser.setUserId("mockAU");
 608
 609         Either<User, ActionStatus> value = Either.left(authUser);
 610         when(userAdminOperation.getUserData("mockAU", false)).thenReturn(value);
 611         when(userAdminOperation.updateUserData(Mockito.any(User.class))).thenReturn(authUser);
 612         assertEquals(authUser.getUserId(), testSubject.authorize(authUser).getUserId());
 613     }
 614
 615     @Test
 616     public void testUpdateUserCredentialsMissingId() {
 617         User updatedUserCred = new User();
 618         updatedUserCred.setUserId(null);
 619         assertTrue(testSubject.updateUserCredentials(updatedUserCred).isRight());
 620     }
 621
 622     @Test(expected = ComponentException.class)
 623     public void testUpdateUserCredentialsFailedToGet() {
 624         User updatedUserCred = new User();
 625         updatedUserCred.setUserId("mock");
 626
 627         Either<User, ActionStatus> value = Either.right(ActionStatus.USER_NOT_FOUND);
 628         when(userAdminOperation.getUserData("mock", false)).thenReturn(value);
 629         testSubject.updateUserCredentials(updatedUserCred);
 630     }
 631
 632     @Test(expected = ComponentException.class)
 633     public void testUpdateUserCredentialsFailedToGet2() {
 634         User updatedUserCred = new User();
 635         updatedUserCred.setUserId("mock");
 636
 637         Either<User, ActionStatus> value = Either.right(ActionStatus.ADDITIONAL_INFORMATION_ALREADY_EXISTS);
 638         when(userAdminOperation.getUserData("mock", false)).thenReturn(value);
 639         testSubject.updateUserCredentials(updatedUserCred);
 640     }
 641
 642     @Test(expected = ComponentException.class)
 643     public void testUpdateUserCredentialsFailedToGet3() {
 644         User updatedUserCred = new User();
 645         updatedUserCred.setUserId("mock");
 646
 647         Either<User, ActionStatus> value = Either.left(null);
 648         when(userAdminOperation.getUserData("mock", false)).thenReturn(value);
 649         testSubject.updateUserCredentials(updatedUserCred);
 650     }
 651
 652     @Test
 653     public void testUpdateUserCredentials() {
 654         User updatedUserCred = new User();
 655         updatedUserCred.setUserId("mock");
 656
 657         Either<User, ActionStatus> value = Either.left(updatedUserCred);
 658         when(userAdminOperation.getUserData("mock", false)).thenReturn(value);
 659
 660         when(userAdminOperation.updateUserData(Mockito.any(User.class))).thenReturn(updatedUserCred);
 661         assertEquals(updatedUserCred.getUserId(),
 662             testSubject.updateUserCredentials(updatedUserCred).left().value().getUserId());
 663     }
 664
 665     @Test
 666     public void getUsersPerRoleWhenListIsEmpty() {
 667         when(userAdminOperation.getAllUsersWithRole(any(), any()))
 668             .thenReturn(Either.left(Lists.newArrayList()));
 669         assertEquals(0, testSubject.getUsersPerRole("all", user, "").left().value().size());
 670     }
 671
 672     @Test
 673     public void getUsersPerRoleWhenListHasMixedElements() {
 674         List<User> users = Lists.newArrayList(user, userNull);
 675         when(user.getUserId()).thenReturn("123");
 676         when(userNull.getUserId()).thenReturn(null);
 677         when(userAdminOperation.getAllUsersWithRole(any(), any()))
 678             .thenReturn(Either.left(users));
 679         List<User> result = testSubject.getUsersPerRole("all", user, "").left().value();
 680
 681         assertEquals(1, result.size());
 682         assertTrue(StringUtils.isNotEmpty(result.get(0).getUserId()));
 683     }
 684
 685     @Test
 686     public void getUsersPerRoleWhenListHasNoneNullElements() {
 687         List<User> users = Lists.newArrayList(user, user);
 688         when(user.getUserId()).thenReturn("123");
 689         when(userAdminOperation.getAllUsersWithRole(any(), any()))
 690             .thenReturn(Either.left(users));
 691         List<User> result = testSubject.getUsersPerRole("all", user, "").left().value();
 692
 693         assertEquals(2, result.size());
 694         assertTrue(StringUtils.isNotEmpty(result.get(0).getUserId()) && StringUtils.isNotEmpty(result.get(1).getUserId()));
 695     }
 696
 697     @Test
 698     public void getUsersPerRoleWhenListHasNullElements() {
 699         List<User> users = Lists.newArrayList(userNull);
 700         when(userNull.getUserId()).thenReturn(null);
 701         when(userAdminOperation.getAllUsersWithRole(any(), any()))
 702             .thenReturn(Either.left(users));
 703         List<User> result = testSubject.getUsersPerRole("all", user, "").left().value();
 704
 705         assertEquals(0, result.size());
 706     }
 707
 708     @Test
 709     public void testHasActiveUserTrue() {
 710         UserContext originalUserContext = null;
 711         try {
 712             originalUserContext = ThreadLocalsHolder.getUserContext();
 713             String userId = "mock";
 714             Set<String> userRoles = new HashSet<>();
 715             userRoles.add(Role.DESIGNER.name());
 716             UserContext userContext = new UserContext(userId, userRoles, "test", "User");
 717             ThreadLocalsHolder.setUserContext(userContext);
 718
 719             assertThat(testSubject.hasActiveUser(userId)).isTrue();
 720         } finally {
 721             ThreadLocalsHolder.setUserContext(originalUserContext);
 722         }
 723     }
 724
 725     @Test
 726     public void testHasActiveUserFalseNoRoles() {
 727         UserContext originalUserContext = null;
 728         try {
 729             originalUserContext = ThreadLocalsHolder.getUserContext();
 730             String userId = "mock";
 731             Set<String> userRoles = new HashSet<>();
 732             UserContext userContext = new UserContext(userId, userRoles, "test", "User");
 733             ThreadLocalsHolder.setUserContext(userContext);
 734
 735             assertThat(testSubject.hasActiveUser(userId)).isFalse();
 736         } finally {
 737             ThreadLocalsHolder.setUserContext(originalUserContext);
 738         }
 739     }
 740
 741     @Test
 742     public void testHasActiveUserFalseNullUserContext() {
 743         UserContext originalUserContext = null;
 744         try {
 745             originalUserContext = ThreadLocalsHolder.getUserContext();
 746             ThreadLocalsHolder.setUserContext(null);
 747
 748             assertThat(testSubject.hasActiveUser(null)).isFalse();
 749         } finally {
 750             ThreadLocalsHolder.setUserContext(originalUserContext);
 751         }
 752     }
 753 }