@Override public boolean isRoot() { return userDto != null && userDto.isRoot(); }
private void verifyRootAndUpdatedAt(String login1, boolean root, long updatedAt) { UserDto userDto = underTest.selectByLogin(session, login1); assertThat(userDto.isRoot()).isEqualTo(root); assertThat(userDto.getUpdatedAt()).isEqualTo(updatedAt); }
@Test public void execute_makes_user_with_specified_login_not_root_when_it_is() { UserDto otherUser = insertRootUser(newUserDto()); insertRootUser(newUserDto(SOME_LOGIN, "name", "email")); logInAsRoot(); executeRequest(SOME_LOGIN); assertThat(userDao.selectByLogin(dbSession, SOME_LOGIN).isRoot()).isFalse(); assertThat(userDao.selectByLogin(dbSession, otherUser.getLogin()).isRoot()).isTrue(); }
@Test public void execute_has_no_effect_when_user_is_already_not_root() { UserDto otherUser = insertRootUser(newUserDto()); insertNonRootUser(newUserDto(SOME_LOGIN, "name", "email")); logInAsRoot(); executeRequest(SOME_LOGIN); assertThat(userDao.selectByLogin(dbSession, SOME_LOGIN).isRoot()).isFalse(); assertThat(userDao.selectByLogin(dbSession, otherUser.getLogin()).isRoot()).isTrue(); }
public void verify(String login, boolean root) { assertThat(db.getDbClient().userDao().selectByLogin(db.getSession(), login).isRoot()) .as("Root flag of user '%s' is '%s'", login, root) .isEqualTo(root); } }
@Test public void execute_makes_user_with_specified_login_root_when_it_is_not() { UserDto otherUser = UserTesting.newUserDto(); userDao.insert(dbSession, otherUser); userDao.insert(dbSession, UserTesting.newUserDto(SOME_LOGIN, "name", "email")); dbSession.commit(); logInAsRoot(); executeRequest(SOME_LOGIN); assertThat(userDao.selectByLogin(dbSession, SOME_LOGIN).isRoot()).isTrue(); assertThat(userDao.selectByLogin(dbSession, otherUser.getLogin()).isRoot()).isFalse(); }
@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(); }
@Override public void handle(Request request, Response response) throws Exception { userSession.checkIsRoot(); String login = request.mandatoryParam(PARAM_LOGIN); try (DbSession dbSession = dbClient.openSession(false)) { UserDto userDto = dbClient.userDao().selectByLogin(dbSession, login); if (userDto == null || !userDto.isActive()) { throw new NotFoundException(format("User with login '%s' not found", login)); } if (!userDto.isRoot()) { dbClient.userDao().setRoot(dbSession, login, true); dbSession.commit(); } } response.noContent(); }
@Test public void setRoot_has_no_effect_on_root_flag_of_inactive_user() { String nonRootInactiveUser = insertUser(false).getLogin(); commit(() -> underTest.setRoot(session, nonRootInactiveUser, true)); assertThat(underTest.selectByLogin(session, nonRootInactiveUser).isRoot()).isFalse(); // create inactive root user UserDto rootUser = insertActiveUser(); commit(() -> underTest.setRoot(session, rootUser.getLogin(), true)); rootUser.setActive(false); commit(() -> underTest.update(session, rootUser)); UserDto inactiveRootUser = underTest.selectByLogin(session, rootUser.getLogin()); assertThat(inactiveRootUser.isRoot()).isTrue(); assertThat(inactiveRootUser.isActive()).isFalse(); commit(() -> underTest.setRoot(session, inactiveRootUser.getLogin(), false)); assertThat(underTest.selectByLogin(session, inactiveRootUser.getLogin()).isRoot()).isTrue(); }
@Test public void authenticate_new_user() { organizationFlags.setEnabled(true); underTest.register(UserRegistration.builder() .setUserIdentity(USER_IDENTITY) .setProvider(IDENTITY_PROVIDER) .setSource(Source.realm(BASIC, IDENTITY_PROVIDER.getName())) .setExistingEmailStrategy(ExistingEmailStrategy.FORBID) .setUpdateLoginStrategy(UpdateLoginStrategy.ALLOW) .build()); UserDto user = db.users().selectUserByLogin(USER_LOGIN).get(); assertThat(user).isNotNull(); assertThat(user.isActive()).isTrue(); assertThat(user.getName()).isEqualTo("John"); assertThat(user.getEmail()).isEqualTo("john@email.com"); assertThat(user.getExternalLogin()).isEqualTo("johndoo"); assertThat(user.getExternalIdentityProvider()).isEqualTo("github"); assertThat(user.getExternalId()).isEqualTo("ABCD"); assertThat(user.isRoot()).isFalse(); checkGroupMembership(user); }
assertThat(dto.getSalt()).isEqualTo("79bd6a8e79fb8c76ac8b121cc7e8e11ad1af8365"); assertThat(dto.getCryptedPassword()).isEqualTo("650d2261c98361e2f67f90ce5c65a95e7d8ea2fg"); assertThat(dto.isRoot()).isFalse(); assertThat(dto.getCreatedAt()).isEqualTo(user1.getCreatedAt()); assertThat(dto.getUpdatedAt()).isEqualTo(user1.getUpdatedAt()); assertThat(dto.isRoot()).isTrue();
@Override public void handle(Request request, Response response) throws Exception { userSession.checkIsRoot(); String login = request.mandatoryParam(PARAM_LOGIN); try (DbSession dbSession = dbClient.openSession(false)) { UserDto userDto = dbClient.userDao().selectByLogin(dbSession, login); if (userDto == null || !userDto.isActive()) { throw new NotFoundException(format("User with login '%s' not found", login)); } checkRequest(dbClient.userDao().countRootUsersButLogin(dbSession, login) > 0, "Last root can't be unset"); if (userDto.isRoot()) { dbClient.userDao().setRoot(dbSession, login, false); dbSession.commit(); } } response.noContent(); }
@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(); }
assertThat(user.getExternalId()).isEqualTo("EXT_ID"); assertThat(user.isLocal()).isTrue(); assertThat(user.isRoot()).isFalse(); assertThat(user.getHomepageType()).isEqualTo("project"); assertThat(user.getHomepageParameter()).isEqualTo("OB1");
@Test public void authenticate_existing_disabled_user() { organizationFlags.setEnabled(true); db.users().insertUser(u -> u .setLogin(USER_LOGIN) .setActive(false) .setName("Old name") .setEmail("Old email") .setExternalId("old id") .setExternalLogin("old identity") .setExternalIdentityProvider("old provide")); underTest.register(UserRegistration.builder() .setUserIdentity(USER_IDENTITY) .setProvider(IDENTITY_PROVIDER) .setSource(Source.local(BASIC)) .setExistingEmailStrategy(ExistingEmailStrategy.FORBID) .setUpdateLoginStrategy(UpdateLoginStrategy.ALLOW) .build()); UserDto userDto = db.users().selectUserByLogin(USER_LOGIN).get(); assertThat(userDto.isActive()).isTrue(); assertThat(userDto.getName()).isEqualTo("John"); assertThat(userDto.getEmail()).isEqualTo("john@email.com"); assertThat(userDto.getExternalId()).isEqualTo("ABCD"); assertThat(userDto.getExternalLogin()).isEqualTo("johndoo"); assertThat(userDto.getExternalIdentityProvider()).isEqualTo("github"); assertThat(userDto.isRoot()).isFalse(); }
assertThat(reloaded.getExternalId()).isEqualTo("EXT_ID"); assertThat(reloaded.isLocal()).isFalse(); assertThat(reloaded.isRoot()).isFalse(); assertThat(reloaded.getHomepageType()).isEqualTo("project"); assertThat(reloaded.getHomepageParameter()).isEqualTo("OB1");
@Test public void create_user() { logInAsSystemAdministrator(); CreateWsResponse response = call(CreateRequest.builder() .setLogin("john") .setName("John") .setEmail("john@email.com") .setScmAccounts(singletonList("jn")) .setPassword("1234") .build()); assertThat(response.getUser()) .extracting(User::getLogin, User::getName, User::getEmail, User::getScmAccountsList, User::getLocal) .containsOnly("john", "John", "john@email.com", singletonList("jn"), true); // exists in index assertThat(es.client().prepareSearch(UserIndexDefinition.INDEX_TYPE_USER) .setQuery(boolQuery() .must(termQuery(FIELD_LOGIN, "john")) .must(termQuery(FIELD_NAME, "John")) .must(termQuery(FIELD_EMAIL, "john@email.com")) .must(termQuery(FIELD_SCM_ACCOUNTS, "jn"))) .get().getHits().getHits()).hasSize(1); // exists in db Optional<UserDto> dbUser = db.users().selectUserByLogin("john"); assertThat(dbUser).isPresent(); assertThat(dbUser.get().isRoot()).isFalse(); // member of default group in default organization assertThat(db.users().selectGroupIdsOfUser(dbUser.get())).containsOnly(defaultGroupInDefaultOrg.getId()); }
@Override public boolean isRoot() { return userDto != null && userDto.isRoot(); }
@Override public void handle(Request request, Response response) throws Exception { userSession.checkIsRoot(); String login = request.mandatoryParam(PARAM_LOGIN); try (DbSession dbSession = dbClient.openSession(false)) { UserDto userDto = dbClient.userDao().selectByLogin(dbSession, login); if (userDto == null || !userDto.isActive()) { throw new NotFoundException(format("User with login '%s' not found", login)); } if (!userDto.isRoot()) { dbClient.userDao().setRoot(dbSession, login, true); dbSession.commit(); } } response.noContent(); }
@Override public void handle(Request request, Response response) throws Exception { userSession.checkIsRoot(); String login = request.mandatoryParam(PARAM_LOGIN); try (DbSession dbSession = dbClient.openSession(false)) { UserDto userDto = dbClient.userDao().selectByLogin(dbSession, login); if (userDto == null || !userDto.isActive()) { throw new NotFoundException(format("User with login '%s' not found", login)); } checkRequest(dbClient.userDao().countRootUsersButLogin(dbSession, login) > 0, "Last root can't be unset"); if (userDto.isRoot()) { dbClient.userDao().setRoot(dbSession, login, false); dbSession.commit(); } } response.noContent(); }