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