How to use

UserQuery$Builder

in

org.sonar.api.user

@Test
public void searchText() {
 UserQuery query = UserQuery.builder().searchText("sim").build();
 assertThat(query.searchText()).isEqualTo("sim");
 assertThat(query.searchTextSql).isEqualTo("%sim%");
}

@Test
public void test_all() throws Exception {
 UserQuery all = UserQuery.builder().includeDeactivated().build();
 assertThat(all.includeDeactivated()).isTrue();
 assertThat(all.logins()).isNull();
}

@Test
public void should_limit_number_of_logins() {
 List<String> logins = new ArrayList<>();
 for (int i = 0; i < 1010; i++) {
  logins.add(String.valueOf(i));
 }
 try {
  UserQuery.builder().logins(logins).build();
  fail();
 } catch (IllegalArgumentException e) {
  assertThat(e).hasMessage("Max number of logins is 1000. Got 1010");
 }
}

public static Builder builder() {
 return new Builder();
}

public static Builder builder() {
 return new Builder();
}

@Override
public void handle(Request request, Response response) throws Exception {
 userSession.checkIsRoot();
 try (DbSession dbSession = dbClient.openSession(false)) {
  List<UserDto> userDtos = dbClient.userDao().selectUsers(
    dbSession,
    UserQuery.builder()
      .mustBeRoot()
      .build());
  writeResponse(request, response, userDtos);
 }
}

@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());
}

public static Builder builder() {
 return new Builder();
}

@Test
public void selectUsersByQuery_escape_special_characters_in_like() {
 db.users().insertUser(user -> user.setLogin("user").setName("User"));
 db.users().insertUser(user -> user.setLogin("sbrandhof").setName("Simon Brandhof"));
 UserQuery query = UserQuery.builder().searchText("%s%").build();
 // we expect really a login or name containing the 3 characters "%s%"
 List<UserDto> users = underTest.selectUsers(session, query);
 assertThat(users).isEmpty();
}

@Test
public void selectUsersByQuery_all() {
 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().includeDeactivated().build());
 assertThat(users).hasSize(2);
}

@Override
public void handle(Request request, Response response) throws Exception {
 userSession.checkIsRoot();
 try (DbSession dbSession = dbClient.openSession(false)) {
  List<UserDto> userDtos = dbClient.userDao().selectUsers(
    dbSession,
    UserQuery.builder()
      .mustBeRoot()
      .build());
  writeResponse(request, response, userDtos);
 }
}

@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 selectUsersByQuery_search_by_name_text() {
 db.users().insertUser(user -> user.setLogin("user").setName("User"));
 db.users().insertUser(user -> user.setLogin("sbrandhof").setName("Simon Brandhof"));
 List<UserDto> users = underTest.selectUsers(session, UserQuery.builder().searchText("Simon").build());
 assertThat(users).extracting(UserDto::getLogin).containsExactlyInAnyOrder("sbrandhof");
}

@Test
public void test_logins() throws Exception {
 UserQuery query = UserQuery.builder().logins("simon", "loic").build();
 assertThat(query.includeDeactivated()).isFalse();
 assertThat(query.logins()).containsOnly("simon", "loic");
 query = UserQuery.builder().logins(Arrays.asList("simon", "loic")).build();
 assertThat(query.logins()).containsOnly("simon", "loic");
}

 @Test
 public void searchText_escape_special_characters_in_like() {
  UserQuery query = UserQuery.builder().searchText("%sim_").build();
  assertThat(query.searchText()).isEqualTo("%sim_");
  assertThat(query.searchTextSql).isEqualTo("%/%sim/_%");
 }
}

@Test
public void selectUsersByQuery_search_by_login_text() {
 db.users().insertUser(user -> user.setLogin("user").setName("User"));
 db.users().insertUser(user -> user.setLogin("sbrandhof").setName("Simon Brandhof"));
 List<UserDto> users = underTest.selectUsers(session, UserQuery.builder().searchText("sbr").build());
 assertThat(users).extracting(UserDto::getLogin).containsExactlyInAnyOrder("sbrandhof");
}