@SafeVarargs public final UserDto insertUser(Consumer<UserDto>... populators) { UserDto dto = newUserDto().setActive(true); stream(populators).forEach(p -> p.accept(dto)); return insertUser(dto); }
private UserDto insertUser(boolean active) { UserDto dto = newUserDto().setActive(active); underTest.insert(session, dto); return dto; }
private UserDto saveUser(DbSession dbSession, UserDto userDto) { userDto.setActive(true); UserDto res = dbClient.userDao().insert(dbSession, userDto); boolean isOrganizationEnabled = organizationFlags.isEnabled(dbSession); if (isOrganizationEnabled) { setNotificationsReadDate(dbSession, userDto); } else { addUserToDefaultOrganizationAndDefaultGroup(dbSession, userDto); } organizationUpdater.createForUser(dbSession, userDto); return res; }
@Test public void fail_if_assignee_is_disabled() { db.users().insertUser(user -> user.setLogin("arthur").setActive(false)); expectedException.expect(NotFoundException.class); expectedException.expectMessage("Unknown user: arthur"); underTest.verify(new HashMap<>(ImmutableMap.of("assignee", "arthur")), singletonList(issue), userSession); }
@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 select_by_external_login_and_identity_provider() { UserDto activeUser = db.users().insertUser(); UserDto disableUser = db.users().insertUser(u -> u.setActive(false)); assertThat(underTest.selectByExternalLoginAndIdentityProvider(session, activeUser.getExternalLogin(), activeUser.getExternalIdentityProvider())).isNotNull(); assertThat(underTest.selectByExternalLoginAndIdentityProvider(session, disableUser.getExternalLogin(), disableUser.getExternalIdentityProvider())).isNotNull(); assertThat(underTest.selectByExternalLoginAndIdentityProvider(session, "unknown", "unknown")).isNull(); }
@Test public void select_by_external_id_and_identity_provider() { UserDto activeUser = db.users().insertUser(); UserDto disableUser = db.users().insertUser(u -> u.setActive(false)); assertThat(underTest.selectByExternalIdAndIdentityProvider(session, activeUser.getExternalId(), activeUser.getExternalIdentityProvider())).isNotNull(); assertThat(underTest.selectByExternalIdAndIdentityProvider(session, disableUser.getExternalId(), disableUser.getExternalIdentityProvider())).isNotNull(); assertThat(underTest.selectByExternalIdAndIdentityProvider(session, "unknown", "unknown")).isNull(); }
private UserDto insertUser() { return db.users().insertUser(newUserDto() .setActive(true) .setEmail("john@email.com") .setLogin(USER_LOGIN) .setName("John") .setScmAccounts(singletonList("jn"))); }
public static UserDto newDisabledUser() { return newUserDto() .setActive(false) // All these fields are reset when disabling a user .setScmAccounts((String) null) .setEmail(null) .setCryptedPassword(null) .setSalt(null); }
@Test public void configured_login_is_disabled() { settings.setProperty(CoreProperties.DEFAULT_ISSUE_ASSIGNEE, "erik"); db.users().insertUser(user -> user.setLogin("erik").setActive(false)); assertThat(underTest.loadDefaultAssigneeUuid()).isNull(); }
@Test public void selectUsersByLogins() { db.users().insertUser(user -> user.setLogin("user1")); db.users().insertUser(user -> user.setLogin("user2")); db.users().insertUser(user -> user.setLogin("inactive_user").setActive(false)); Collection<UserDto> users = underTest.selectByLogins(session, asList("user1", "inactive_user", "other")); assertThat(users).extracting("login").containsExactlyInAnyOrder("user1", "inactive_user"); }
@Test public void selectUsersByQuery_only_actives() { db.users().insertUser(user -> user.setLogin("user").setName("User")); db.users().insertUser(user -> user.setLogin("inactive_user").setName("Disabled").setActive(false)); List<UserDto> users = underTest.selectUsers(session, UserQuery.ALL_ACTIVES); assertThat(users).extracting(UserDto::getName).containsExactlyInAnyOrder("User"); }
@Test public void selectUserByLogin_ignore_inactive() { db.users().insertUser(user -> user.setLogin("user1")); db.users().insertUser(user -> user.setLogin("user2")); db.users().insertUser(user -> user.setLogin("inactive_user").setActive(false)); UserDto user = underTest.selectActiveUserByLogin(session, "inactive_user"); assertThat(user).isNull(); }
@Test public void execute_fails_with_NotFoundException_when_user_for_specified_login_is_inactive() { UserDto userDto = insertRootUser(newUserDto().setActive(false)); logInAsRoot(); expectedException.expect(NotFoundException.class); expectedException.expectMessage("User with login '" + userDto.getLogin() + "' not found"); executeRequest(userDto.getLogin()); }
@Test public void execute_fails_with_NotFoundException_when_user_for_specified_login_is_not_active() { UserDto userDto = UserTesting.newUserDto().setActive(false); userDao.insert(dbSession, userDto); dbSession.commit(); logInAsRoot(); expectedException.expect(NotFoundException.class); expectedException.expectMessage("User with login '" + userDto.getLogin() + "' not found"); executeRequest(userDto.getLogin()); }
@Test public void selectUsersByQuery_filter_by_login() { db.users().insertUser(user -> user.setLogin("user").setName("User")); db.users().insertUser(user -> user.setLogin("inactive_user").setName("Disabled").setActive(false)); List<UserDto> users = underTest.selectUsers(session, UserQuery.builder().logins("user", "john").build()); assertThat(users).extracting(UserDto::getName).containsExactlyInAnyOrder("User"); }
@Test public void fail_on_disabled_user() { UserDto userDto = db.users().insertUser(user -> user.setLogin("disabled").setActive(false)); insertDefaultGroup("sonar-users", "Sonar Users"); expectedException.expect(NotFoundException.class); expectedException.expectMessage("Unknown user: disabled"); call(ws.newRequest().setParam("login", userDto.getLogin())); }
@Test public void fail_on_disabled_user() { db.users().insertUser(u -> u.setLogin("polop").setActive(false)); userSessionRule.logIn().setSystemAdministrator(); expectedException.expect(NotFoundException.class); expectedException.expectMessage("User with login 'polop' has not been found"); tester.newRequest() .setParam("login", "polop") .setParam("password", "polop") .execute(); }
@Test public void authenticate_existing_user_and_add_new_groups() { organizationFlags.setEnabled(true); UserDto user = db.users().insertUser(newUserDto() .setLogin(USER_LOGIN) .setActive(true) .setName("John")); GroupDto group1 = db.users().insertGroup(db.getDefaultOrganization(), "group1"); GroupDto group2 = db.users().insertGroup(db.getDefaultOrganization(), "group2"); authenticate(USER_LOGIN, "group1", "group2", "group3"); checkGroupMembership(user, group1, group2); }
@Before public void setUp() throws Exception { organizationDto = db.organizations().insert(); user1 = db.users().insertUser(u -> u.setLogin("admin login").setName("Admin name").setEmail("admin@email.com")); user2 = db.users().insertUser(u -> u.setLogin("not.admin").setName("Not Admin").setEmail("Not Admin")); user3 = db.users().insertUser(u -> u.setLogin("inactive").setActive(false)); group1 = db.users().insertGroup(organizationDto, "sonar-administrators"); group2 = db.users().insertGroup(organizationDto, "sonar-users"); group3 = db.users().insertGroup(organizationDto, "sonar-reviewers"); db.organizations().addMember(organizationDto, user1); db.organizations().addMember(organizationDto, user2); }