@Test public void selectByUuid() { UserDto user1 = db.users().insertUser(); UserDto user2 = db.users().insertUser(user -> user.setActive(false)); assertThat(underTest.selectByUuid(session, user1.getUuid())).isNotNull(); assertThat(underTest.selectByUuid(session, user2.getUuid())).isNotNull(); assertThat(underTest.selectByUuid(session, "unknown")).isNull(); }
@Test public void clean_user_homepage() { UserDto user = newUserDto().setHomepageType("RANDOM").setHomepageParameter("any-string"); underTest.insert(session, user); session.commit(); underTest.cleanHomepage(session, user); UserDto reloaded = underTest.selectUserById(session, user.getId()); assertThat(reloaded.getUpdatedAt()).isEqualTo(NOW); assertThat(reloaded.getHomepageType()).isNull(); assertThat(reloaded.getHomepageParameter()).isNull(); }
@CheckForNull private UserDto getUser(DbSession dbSession, @Nullable String assignee) { if (Strings.isNullOrEmpty(assignee)) { return null; } return checkFound(dbClient.userDao().selectActiveUserByLogin(dbSession, assignee), "Unknown user: %s", assignee); }
@Test public void execute_has_no_effect_when_user_is_already_root() { UserDto otherUser = UserTesting.newUserDto(); userDao.insert(dbSession, otherUser); userDao.insert(dbSession, UserTesting.newUserDto(SOME_LOGIN, "name", "email")); userDao.setRoot(dbSession, SOME_LOGIN, true); dbSession.commit(); logInAsRoot(); executeRequest(SOME_LOGIN); assertThat(userDao.selectByLogin(dbSession, SOME_LOGIN).isRoot()).isTrue(); assertThat(userDao.selectByLogin(dbSession, otherUser.getLogin()).isRoot()).isFalse(); }
private Optional<UserDto> detectEmailUpdate(DbSession dbSession, UserRegistration authenticatorParameters) { String email = authenticatorParameters.getUserIdentity().getEmail(); if (email == null) { return Optional.empty(); } List<UserDto> existingUsers = dbClient.userDao().selectByEmail(dbSession, email); if (existingUsers.isEmpty()) { return Optional.empty(); } if (existingUsers.size() > 1) { throw generateExistingEmailError(authenticatorParameters, email); } UserDto existingUser = existingUsers.get(0); if (existingUser == null || isSameUser(existingUser, authenticatorParameters)) { return Optional.empty(); } ExistingEmailStrategy existingEmailStrategy = authenticatorParameters.getExistingEmailStrategy(); switch (existingEmailStrategy) { case ALLOW: existingUser.setEmail(null); dbClient.userDao().update(dbSession, existingUser); return Optional.of(existingUser); case WARN: throw new EmailAlreadyExistsRedirectionException(email, existingUser, authenticatorParameters.getUserIdentity(), authenticatorParameters.getProvider()); case FORBID: throw generateExistingEmailError(authenticatorParameters, email); default: throw new IllegalStateException(format("Unknown strategy %s", existingEmailStrategy)); } }
@Test public void execute_succeeds_when_root_user_has_neither_email_nor_name() { logInAsRoot(); UserDto rootDto = userDao.insert(dbSession, UserTesting.newUserDto().setName(null).setEmail(null)); userDao.setRoot(dbSession, rootDto.getLogin(), true); dbSession.commit(); List<Roots.RootContent> roots = executeRequest(); assertThat(roots).hasSize(1); Roots.RootContent root = roots.iterator().next(); assertThat(root.getLogin()).isEqualTo(rootDto.getLogin()); assertThat(root.hasName()).isFalse(); assertThat(root.hasEmail()).isFalse(); }
@Test public void selectUsers_returns_both_only_root_or_only_non_root_depending_on_mustBeRoot_and_mustNotBeRoot_calls_on_query() { UserDto user1 = insertUser(true); UserDto root1 = insertRootUser(newUserDto()); UserDto user2 = insertUser(true); UserDto root2 = insertRootUser(newUserDto()); assertThat(underTest.selectUsers(session, UserQuery.builder().build())) .extracting(UserDto::getLogin) .containsOnly(user1.getLogin(), user2.getLogin(), root1.getLogin(), root2.getLogin()); assertThat(underTest.selectUsers(session, UserQuery.builder().mustBeRoot().build())) .extracting(UserDto::getLogin) .containsOnly(root1.getLogin(), root2.getLogin()); assertThat(underTest.selectUsers(session, UserQuery.builder().mustNotBeRoot().build())) .extracting(UserDto::getLogin) .containsOnly(user1.getLogin(), user2.getLogin()); }
@Test public void authenticate_new_user_generate_login_when_no_login_provided() { organizationFlags.setEnabled(true); underTest.register(UserRegistration.builder() .setUserIdentity(UserIdentity.builder() .setProviderId("ABCD") .setProviderLogin("johndoo") .setName("John Doe") .setEmail("john@email.com") .build()) .setProvider(IDENTITY_PROVIDER) .setSource(Source.realm(BASIC, IDENTITY_PROVIDER.getName())) .setExistingEmailStrategy(ExistingEmailStrategy.FORBID) .setUpdateLoginStrategy(UpdateLoginStrategy.ALLOW) .build()); UserDto user = db.getDbClient().userDao().selectByEmail(db.getSession(), "john@email.com").get(0); assertThat(user).isNotNull(); assertThat(user.isActive()).isTrue(); assertThat(user.getLogin()).isNotEqualTo("John Doe").startsWith("john-doe"); assertThat(user.getEmail()).isEqualTo("john@email.com"); assertThat(user.getExternalLogin()).isEqualTo("johndoo"); assertThat(user.getExternalIdentityProvider()).isEqualTo("github"); assertThat(user.getExternalId()).isEqualTo("ABCD"); }
@Test public void remove_scm_accounts() { createUser(); ws.newRequest() .setParam("login", "john") .setMultiParam("scmAccount", singletonList("")) .execute(); UserDto userDto = dbClient.userDao().selectByLogin(dbSession, "john"); assertThat(userDto.getScmAccounts()).isNull(); }
@Test public void update_only_login_of_external_account() { UserDto user = db.users().insertUser(newExternalUser(DEFAULT_LOGIN, "Marius", "marius@lesbronzes.fr")); createDefaultGroup(); underTest.updateAndCommit(session, user, new UpdateUser() .setLogin("new_login"), u -> { }); assertThat(dbClient.userDao().selectByLogin(session, DEFAULT_LOGIN)).isNull(); UserDto userReloaded = dbClient.userDao().selectByUuid(session, user.getUuid()); assertThat(userReloaded.getLogin()).isEqualTo("new_login"); // Following fields has not changed assertThat(userReloaded.isLocal()).isFalse(); assertThat(userReloaded.getExternalLogin()).isEqualTo(user.getExternalLogin()); assertThat(userReloaded.getExternalId()).isEqualTo(user.getExternalId()); assertThat(userReloaded.getName()).isEqualTo(user.getName()); assertThat(userReloaded.getEmail()).isEqualTo(user.getEmail()); assertThat(userReloaded.getScmAccountsAsList()).containsAll(user.getScmAccountsAsList()); assertThat(userReloaded.getSalt()).isEqualTo(user.getSalt()); assertThat(userReloaded.getCryptedPassword()).isEqualTo(user.getCryptedPassword()); }
@Test public void reactivate_user_without_providing_login() { UserDto user = db.users().insertUser(u -> u.setActive(false)); createDefaultGroup(); underTest.reactivateAndCommit(db.getSession(), user, NewUser.builder() .setName("Marius2") .setEmail("marius2@mail.com") .setPassword("password2") .build(), u -> { }); UserDto reloaded = dbClient.userDao().selectByUuid(session, user.getUuid()); assertThat(reloaded.isActive()).isTrue(); assertThat(reloaded.getLogin()).isEqualTo(user.getLogin()); }
@Test public void update_scm_account_having_coma() { createUser(); ws.newRequest() .setParam("login", "john") .setMultiParam("scmAccount", singletonList("jon,snow")) .execute(); UserDto user = dbClient.userDao().selectByLogin(dbSession, "john"); assertThat(user.getScmAccountsAsList()).containsOnly("jon,snow"); }
@Test public void create_user_generates_unique_login_no_login_provided() { createDefaultGroup(); UserDto user = underTest.createAndCommit(db.getSession(), NewUser.builder() .setName("John Doe") .build(), u -> { }); UserDto dto = dbClient.userDao().selectByLogin(session, user.getLogin()); assertThat(dto.getLogin()).startsWith("john-doe"); assertThat(dto.getName()).isEqualTo("John Doe"); }
@Test public void create_not_onboarded_user_if_onboarding_setting_is_set_to_false() { settings.setProperty(ONBOARDING_TUTORIAL_SHOW_TO_NEW_USERS.getKey(), false); createDefaultGroup(); underTest.createAndCommit(db.getSession(), NewUser.builder() .setLogin("user") .setName("User") .build(), u -> { }); assertThat(dbClient.userDao().selectByLogin(session, "user").isOnboarded()).isTrue(); }
@Test public void deactivate_user() { UserDto user = insertActiveUser(); insertUserGroup(user); UserDto otherUser = insertActiveUser(); session.commit(); underTest.deactivateUser(session, user); UserDto userReloaded = underTest.selectUserById(session, user.getId()); assertThat(userReloaded.isActive()).isFalse(); assertThat(userReloaded.getLogin()).isNotNull(); assertThat(userReloaded.getExternalId()).isNotNull(); assertThat(userReloaded.getExternalLogin()).isNotNull(); assertThat(userReloaded.getExternalIdentityProvider()).isNotNull(); assertThat(userReloaded.getEmail()).isNull(); assertThat(userReloaded.getScmAccounts()).isNull(); assertThat(userReloaded.getSalt()).isNull(); assertThat(userReloaded.getCryptedPassword()).isNull(); assertThat(userReloaded.isRoot()).isFalse(); assertThat(userReloaded.getUpdatedAt()).isEqualTo(NOW); assertThat(userReloaded.getHomepageType()).isNull(); assertThat(userReloaded.getHomepageParameter()).isNull(); assertThat(underTest.selectUserById(session, otherUser.getId())).isNotNull(); }
@Test public void create_onboarded_user_if_onboarding_setting_is_set_to_true() { settings.setProperty(ONBOARDING_TUTORIAL_SHOW_TO_NEW_USERS.getKey(), true); createDefaultGroup(); underTest.createAndCommit(db.getSession(), NewUser.builder() .setLogin("user") .setName("User") .build(), u -> { }); assertThat(dbClient.userDao().selectByLogin(session, "user").isOnboarded()).isFalse(); }
@Test public void select_by_email() { UserDto activeUser1 = db.users().insertUser(u -> u.setEmail("user1@email.com")); UserDto activeUser2 = db.users().insertUser(u -> u.setEmail("user1@email.com")); UserDto disableUser = db.users().insertUser(u -> u.setActive(false)); assertThat(underTest.selectByEmail(session, "user1@email.com")).hasSize(2); assertThat(underTest.selectByEmail(session, disableUser.getEmail())).isEmpty(); assertThat(underTest.selectByEmail(session, "unknown")).isEmpty(); }
@Test public void set_SonarCloud_my_issues_homepage() { UserDto user = db.users().insertUser(); userSession.logIn(user); ws.newRequest() .setMethod("POST") .setParam(PARAM_TYPE, "MY_ISSUES") .execute(); UserDto actual = db.getDbClient().userDao().selectByLogin(db.getSession(), user.getLogin()); assertThat(actual).isNotNull(); assertThat(actual.getHomepageType()).isEqualTo("MY_ISSUES"); assertThat(actual.getHomepageParameter()).isNullOrEmpty(); }
@Test public void massSubmit_returns_tasks_for_each_CeTaskSubmit_populated_from_CeTaskSubmit_and_creates_CeQueue_row_for_each() { CeTaskSubmit taskSubmit1 = createTaskSubmit(CeTaskTypes.REPORT, newProjectDto("PROJECT_1"), "rob"); CeTaskSubmit taskSubmit2 = createTaskSubmit("some type"); List<CeTask> tasks = underTest.massSubmit(asList(taskSubmit1, taskSubmit2)); UserDto userDto1 = db.getDbClient().userDao().selectByUuid(db.getSession(), taskSubmit1.getSubmitterUuid()); assertThat(tasks).hasSize(2); verifyCeTask(taskSubmit1, tasks.get(0), null, userDto1); verifyCeTask(taskSubmit2, tasks.get(1), null, null); verifyCeQueueDtoForTaskSubmit(taskSubmit1); verifyCeQueueDtoForTaskSubmit(taskSubmit2); }
@Test public void update_personal_organization_when_updating_login() { userSession.logIn().setSystemAdministrator(); String oldLogin = "old_login"; OrganizationDto personalOrganization = db.organizations().insert(o -> o.setKey(oldLogin).setGuarded(true)); UserDto user = db.users().insertUser(u -> u.setLogin(oldLogin).setOrganizationUuid(personalOrganization.getUuid())); ws.newRequest() .setParam("login", oldLogin) .setParam("newLogin", "new_login") .execute(); UserDto userReloaded = db.getDbClient().userDao().selectByUuid(db.getSession(), user.getUuid()); assertThat(userReloaded.getLogin()).isEqualTo("new_login"); OrganizationDto organizationReloaded = db.getDbClient().organizationDao().selectByUuid(db.getSession(), personalOrganization.getUuid()).get(); assertThat(organizationReloaded.getKey()).isEqualTo("new_login"); }