package org.sonar.core.user;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableMap;
+import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.session.SqlSession;
import org.sonar.core.persistence.MyBatis;
import java.util.List;
+import java.util.Map;
public class GroupMembershipDao {
private final MyBatis mybatis;
- public List<GroupMembershipDto> selectGroups(GroupMembershipQuery query) {
+ public List<GroupMembershipDto> selectGroups(GroupMembershipQuery query, Long userId, int offset, int limit) {
SqlSession session = mybatis.openSession();
try {
- GroupMembershipMapper mapper = session.getMapper(GroupMembershipMapper.class);
- return mapper.selectGroups(query);
+ Map<String, Object> params = ImmutableMap.of("query", query, "userId", userId);
+ return session.selectList("org.sonar.core.user.GroupMembershipMapper.selectGroups", params, new RowBounds(offset, limit));
} finally {
MyBatis.closeQuietly(session);
}
}
+ @VisibleForTesting
+ List<GroupMembershipDto> selectGroups(GroupMembershipQuery query, Long userId) {
+ return selectGroups(query, userId, 0, Integer.MAX_VALUE);
+ }
+
}
public static final int DEFAULT_PAGE_INDEX = 1;
public static final int DEFAULT_PAGE_SIZE = 100;
- public static final String ALL = "ALL";
- public static final String MEMBER_ONLY = "MEMBER_ONLY";
- public static final String NOT_MEMBER = "NOT_MEMBER";
- public static final Set<String> AVAILABLE_MEMBERSHIP = ImmutableSet.of(ALL, MEMBER_ONLY, NOT_MEMBER);
+ public static final String ANY = "ANY";
+ public static final String IN = "IN";
+ public static final String OUT = "OUT";
+ public static final Set<String> AVAILABLE_MEMBERSHIP = ImmutableSet.of(ANY, IN, OUT);
- private final Long userId;
- private final String memberShip;
+ private final String login;
+ private final String membership;
- private final String searchText;
+ private final String groupSearch;
// for internal use in MyBatis
- final String searchTextSql;
+ final String groupSearchSql;
// max results per page
private final int pageSize;
private GroupMembershipQuery(Builder builder) {
- this.userId = builder.userId;
- this.memberShip = builder.memberShip;
- this.searchText = builder.searchText;
- this.searchTextSql = searchTextToSql(searchText);
+ this.login = builder.login;
+ this.membership = builder.membership;
+ this.groupSearch = builder.groupSearch;
+ this.groupSearchSql = groupSearchToSql(groupSearch);
this.pageSize = builder.pageSize;
this.pageIndex = builder.pageIndex;
}
- private String searchTextToSql(@Nullable String s) {
+ private String groupSearchToSql(@Nullable String s) {
String sql = null;
if (s != null) {
sql = StringUtils.replace(s, "%", "/%");
return sql;
}
- public Long userId() {
- return userId;
+ public String login() {
+ return login;
}
@CheckForNull
- public String memberShip() {
- return memberShip;
+ public String membership() {
+ return membership;
}
/**
* Search for groups or names containing a given string
*/
@CheckForNull
- public String searchText() {
- return searchText;
+ public String groupSearch() {
+ return groupSearch;
}
public int pageSize() {
}
public static class Builder {
- private Long userId;
- private String memberShip = GroupMembershipQuery.ALL;
- private String searchText;
+ private String login;
+ private String membership;
+ private String groupSearch;
private Integer pageIndex = DEFAULT_PAGE_INDEX;
private Integer pageSize = DEFAULT_PAGE_SIZE;
private Builder() {
}
- public Builder userId(Long userId) {
- this.userId = userId;
+ public Builder login(String login) {
+ this.login = login;
return this;
}
- public Builder memberShip(@Nullable String memberShip) {
- this.memberShip = memberShip;
+ public Builder membership(@Nullable String membership) {
+ this.membership = membership;
return this;
}
- public Builder searchText(@Nullable String s) {
- this.searchText = StringUtils.defaultIfBlank(s, null);
+ public Builder groupSearch(@Nullable String s) {
+ this.groupSearch = StringUtils.defaultIfBlank(s, null);
return this;
}
return this;
}
+ private void initMembership() {
+ if (membership == null) {
+ membership = GroupMembershipQuery.ANY;
+ } else {
+ // TODO check
+ }
+ }
+
+ private void initPageSize() {
+ if (pageSize == null) {
+ pageSize = DEFAULT_PAGE_SIZE;
+ }
+ }
+
private void initPageIndex() {
+ if (pageIndex == null) {
+ pageIndex = DEFAULT_PAGE_INDEX;
+ }
Preconditions.checkArgument(pageIndex > 0, "Page index must be greater than 0 (got " + pageIndex + ")");
}
public GroupMembershipQuery build() {
- Preconditions.checkNotNull(userId, "User id cant be null.");
+ Preconditions.checkNotNull(login, "User cant be null.");
+ initMembership();
+ initPageIndex();
+ initPageSize();
return new GroupMembershipQuery(this);
}
}
<sql id="groupColumns">
g.id as id,
- g.name as name
+ g.name as name,
+ gu.user_id as userId
</sql>
<select id="selectGroups" parameterType="map" resultType="GroupMembership">
- SELECT g.id as id, g.name as name, gu.user_id as userId
+ SELECT <include refid="groupColumns"/>
FROM groups g
+ <include refid="selectQueryConditions"/>
+ ORDER BY g.name
+ </select>
+
+ <sql id="selectQueryConditions">
LEFT JOIN groups_users gu ON gu.group_id=g.id AND gu.user_id=#{userId}
<where>
<choose>
- <when test="memberShip == 'MEMBER_ONLY'">
- AND gu.user_id is not null
+ <when test="query.membership() == 'IN'">
+ AND gu.user_id IS NOT NULL
</when>
- <when test="memberShip == 'NOT_MEMBER'">
- AND gu.user_id is null
+ <when test="query.membership() == 'OUT'">
+ AND gu.user_id IS NULL
</when>
</choose>
- <if test="searchText != null">
- AND (g.name LIKE #{searchTextSql} ESCAPE '/')
+ <if test="query.groupSearch() != null">
+ AND (g.name LIKE #{query.groupSearchSql} ESCAPE '/')
</if>
</where>
- ORDER BY g.name
- </select>
+ </sql>
</mapper>
public void select_all_groups_by_query() throws Exception {
setupData("shared");
- GroupMembershipQuery query = GroupMembershipQuery.builder().userId(200L).build();
- List<GroupMembershipDto> result = dao.selectGroups(query);
+ GroupMembershipQuery query = GroupMembershipQuery.builder().login("arthur").build();
+ List<GroupMembershipDto> result = dao.selectGroups(query, 200L);
assertThat(result).hasSize(3);
}
public void select_user_group() throws Exception {
setupData("select_user_group");
- GroupMembershipQuery query = GroupMembershipQuery.builder().userId(201L).build();
- List<GroupMembershipDto> result = dao.selectGroups(query);
+ GroupMembershipQuery query = GroupMembershipQuery.builder().login("arthur").build();
+ List<GroupMembershipDto> result = dao.selectGroups(query, 201L);
assertThat(result).hasSize(1);
GroupMembershipDto dto = result.get(0);
setupData("shared");
// 200 is member of 3 groups
- assertThat(dao.selectGroups(GroupMembershipQuery.builder().userId(200L).memberShip(GroupMembershipQuery.MEMBER_ONLY).build())).hasSize(3);
+ assertThat(dao.selectGroups(GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.IN).build(), 200L)).hasSize(3);
// 201 is member of 1 group on 3
- assertThat(dao.selectGroups(GroupMembershipQuery.builder().userId(201L).memberShip(GroupMembershipQuery.MEMBER_ONLY).build())).hasSize(1);
+ assertThat(dao.selectGroups(GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.IN).build(), 201L)).hasSize(1);
// 999 is member of 0 group
- assertThat(dao.selectGroups(GroupMembershipQuery.builder().userId(999L).memberShip(GroupMembershipQuery.MEMBER_ONLY).build())).isEmpty();
+ assertThat(dao.selectGroups(GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.IN).build(), 999L)).isEmpty();
}
@Test
setupData("shared");
// 200 is member of 3 groups
- assertThat(dao.selectGroups(GroupMembershipQuery.builder().userId(200L).memberShip(GroupMembershipQuery.NOT_MEMBER).build())).isEmpty();
+ assertThat(dao.selectGroups(GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.OUT).build(), 200L)).isEmpty();
// 201 is member of 1 group on 3
- assertThat(dao.selectGroups(GroupMembershipQuery.builder().userId(201L).memberShip(GroupMembershipQuery.NOT_MEMBER).build())).hasSize(2);
+ assertThat(dao.selectGroups(GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.OUT).build(), 201L)).hasSize(2);
// 999 is member of 0 group
- assertThat(dao.selectGroups(GroupMembershipQuery.builder().userId(999L).memberShip(GroupMembershipQuery.NOT_MEMBER).build())).hasSize(3);
+ assertThat(dao.selectGroups(GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.OUT).build(), 2999L)).hasSize(3);
}
@Test
public void select_only_matching_group_name() throws Exception {
setupData("shared");
- List<GroupMembershipDto> result = dao.selectGroups(GroupMembershipQuery.builder().userId(200L).searchText("user").build());
+ List<GroupMembershipDto> result = dao.selectGroups(GroupMembershipQuery.builder().login("arthur").groupSearch("user").build(), 200L);
assertThat(result).hasSize(1);
assertThat(result.get(0).getName()).isEqualTo("sonar-users");
- result = dao.selectGroups(GroupMembershipQuery.builder().userId(200L).searchText("sonar").build());
+ result = dao.selectGroups(GroupMembershipQuery.builder().login("arthur").groupSearch("sonar").build(), 200L);
assertThat(result).hasSize(3);
}
public void should_be_sorted_by_group_name() throws Exception {
setupData("should_be_sorted_by_group_name");
- List<GroupMembershipDto> result = dao.selectGroups(GroupMembershipQuery.builder().userId(200L).memberShip(GroupMembershipQuery.ALL).build());
+ List<GroupMembershipDto> result = dao.selectGroups(GroupMembershipQuery.builder().login("arthur").build(), 200L);
assertThat(result).hasSize(3);
assertThat(result.get(0).getName()).isEqualTo("sonar-administrators");
assertThat(result.get(1).getName()).isEqualTo("sonar-reviewers");
assertThat(result.get(2).getName()).isEqualTo("sonar-users");
}
+ @Test
+ public void should_be_paginated() throws Exception {
+ setupData("shared");
+
+ List<GroupMembershipDto> result = dao.selectGroups(GroupMembershipQuery.builder().login("arthur").build(), 200L, 0, 2);
+ assertThat(result).hasSize(2);
+ assertThat(result.get(0).getName()).isEqualTo("sonar-administrators");
+ assertThat(result.get(1).getName()).isEqualTo("sonar-reviewers");
+
+ result = dao.selectGroups(GroupMembershipQuery.builder().login("arthur").build(), 200L, 1, 2);
+ assertThat(result).hasSize(2);
+ assertThat(result.get(0).getName()).isEqualTo("sonar-reviewers");
+ assertThat(result.get(1).getName()).isEqualTo("sonar-users");
+
+ result = dao.selectGroups(GroupMembershipQuery.builder().login("arthur").build(), 200L, 2, 1);
+ assertThat(result).hasSize(1);
+ assertThat(result.get(0).getName()).isEqualTo("sonar-users");
+ }
+
}
--- /dev/null
+/*
+ * SonarQube, open source software quality management tool.
+ * Copyright (C) 2008-2013 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * SonarQube is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * SonarQube is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+package org.sonar.server.group;
+
+import org.sonar.api.ServerComponent;
+import org.sonar.core.user.*;
+import org.sonar.server.exceptions.NotFoundException;
+
+import java.util.List;
+
+import static com.google.common.collect.Lists.newArrayList;
+
+public class GroupMembershipFinder implements ServerComponent {
+
+ private final UserDao userDao;
+ private final GroupMembershipDao groupMembershipDao;
+
+ public GroupMembershipFinder(UserDao userDao, GroupMembershipDao groupMembershipDao) {
+ this.userDao = userDao;
+ this.groupMembershipDao = groupMembershipDao;
+ }
+
+ public GroupMembershipQueryResult find(GroupMembershipQuery query) {
+ Long userId = userId(query.login());
+ int pageSize = query.pageSize();
+ int pageIndex = query.pageIndex();
+
+ int offset = (pageIndex - 1) * pageSize;
+ // Add one to page size in order to be able to know if there's more results or not
+ int limit = pageSize + 1;
+ List<GroupMembershipDto> dtos = groupMembershipDao.selectGroups(query, userId, offset, limit);
+ boolean hasMoreResults = false;
+ if (dtos.size() == limit) {
+ hasMoreResults = true;
+ // Removed last entry as it's only need to know if there more results or not
+ dtos.remove(dtos.size() - 1);
+ }
+ return new GroupMembershipQueryResult(toGroupMembership(dtos), hasMoreResults);
+ }
+
+ private Long userId(String login) {
+ UserDto userDto = userDao.selectActiveUserByLogin(login);
+ if (userDto == null) {
+ throw new NotFoundException("User '"+ login +"' does not exists.");
+ }
+ return userDto.getId();
+ }
+
+ private List<GroupMembership> toGroupMembership(List<GroupMembershipDto> dtos) {
+ List<GroupMembership> groups = newArrayList();
+ for (GroupMembershipDto groupMembershipDto : dtos) {
+ groups.add(groupMembershipDto.toDefaultGroupMembership());
+ }
+ return groups;
+ }
+}
--- /dev/null
+/*
+ * SonarQube, open source software quality management tool.
+ * Copyright (C) 2008-2013 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * SonarQube is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * SonarQube is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.group;
+
+import org.sonar.core.user.GroupMembership;
+
+import java.util.List;
+
+public class GroupMembershipQueryResult {
+
+ private List<GroupMembership> groups;
+ private boolean hasMoreResults;
+
+ public GroupMembershipQueryResult(List<GroupMembership> groups, boolean hasMoreResults) {
+ this.groups = groups;
+ this.hasMoreResults = hasMoreResults;
+ }
+
+ public List<GroupMembership> groups() {
+ return groups;
+ }
+
+ public boolean hasMoreResults() {
+ return hasMoreResults;
+ }
+
+}
package org.sonar.server.group;
import org.sonar.api.ServerComponent;
-import org.sonar.core.user.*;
-import org.sonar.server.exceptions.NotFoundException;
+import org.sonar.core.user.GroupMembershipQuery;
+import org.sonar.server.util.RubyUtils;
-import java.util.List;
import java.util.Map;
-import static com.google.common.collect.Lists.newArrayList;
-
/**
- * Used by ruby code <pre>Internal.groupmembership</pre>
+ * Used by ruby code <pre>Internal.group_membership</pre>
*/
public class InternalGroupMembershipQueryService implements ServerComponent {
- private final UserDao userDao;
- private final GroupMembershipDao groupMembershipDao;
+ private final GroupMembershipFinder finder;
- public InternalGroupMembershipQueryService(UserDao userDao, GroupMembershipDao groupMembershipDao) {
- this.userDao = userDao;
- this.groupMembershipDao = groupMembershipDao;
+ public InternalGroupMembershipQueryService(GroupMembershipFinder finder) {
+ this.finder = finder;
}
- public List<GroupMembership> find(Map<String, String> params) {
- List<GroupMembership> groupMemberships = newArrayList();
- String user = user(params);
- UserDto userDto = userDao.selectActiveUserByLogin(user);
- if (userDto == null) {
- throw new NotFoundException("User '"+ user +"' does not exists.");
- }
- List<GroupMembershipDto> dtos = groupMembershipDao.selectGroups(parseQuery(params, userDto.getId()));
- for (GroupMembershipDto dto : dtos){
- groupMemberships.add(dto.toDefaultGroupMembership());
- }
- return groupMemberships;
+ public GroupMembershipQueryResult find(Map<String, Object> params) {
+ return finder.find(parseQuery(params));
}
- private GroupMembershipQuery parseQuery(Map<String, String> params, Long userId) {
+ private GroupMembershipQuery parseQuery(Map<String, Object> params) {
GroupMembershipQuery.Builder builder = GroupMembershipQuery.builder();
- builder.memberShip(memberShip(params));
- builder.searchText(params.get("query"));
- builder.userId(userId);
+ builder.membership(membership(params));
+ builder.groupSearch((String) params.get("query"));
+ builder.pageIndex(RubyUtils.toInteger(params.get("page")));
+ builder.pageSize(RubyUtils.toInteger(params.get("pageSize")));
+ builder.login((String) params.get("login"));
return builder.build();
}
- private String user(Map<String, String> params){
- return params.get("user");
- }
-
- private String memberShip(Map<String, String> params){
- String selected = params.get("selected");
+ private String membership(Map<String, Object> params) {
+ String selected = (String) params.get("selected");
if ("selected".equals(selected)) {
- return GroupMembershipQuery.MEMBER_ONLY;
+ return GroupMembershipQuery.IN;
} else if ("deselected".equals(selected)) {
- return GroupMembershipQuery.NOT_MEMBER;
+ return GroupMembershipQuery.OUT;
} else {
- return GroupMembershipQuery.ALL;
+ return GroupMembershipQuery.ANY;
}
}
}
import org.sonar.server.db.migrations.DatabaseMigration;
import org.sonar.server.db.migrations.DatabaseMigrations;
import org.sonar.server.db.migrations.DatabaseMigrator;
+import org.sonar.server.group.GroupMembershipFinder;
import org.sonar.server.group.InternalGroupMembershipQueryService;
import org.sonar.server.issue.*;
import org.sonar.server.notifications.NotificationCenter;
// groups
servicesContainer.addSingleton(InternalGroupMembershipQueryService.class);
+ servicesContainer.addSingleton(GroupMembershipFinder.class);
// components
servicesContainer.addSingleton(DefaultComponentFinder.class);
#
#
def search
- groups = Internal.group_membership.find(params)
+ result = Internal.group_membership.find(params)
+ groups = result.groups()
+ more = result.hasMoreResults()
respond_to do |format|
format.json {
render :json => {
- :more => false,
+ :more => more,
:results => groups.map { |group| {
:id => group.id(),
:name => group.name(),
--- /dev/null
+/*
+ * SonarQube, open source software quality management tool.
+ * Copyright (C) 2008-2013 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * SonarQube is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * SonarQube is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+package org.sonar.server.group;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.sonar.core.user.*;
+
+import static com.google.common.collect.Lists.newArrayList;
+import static org.fest.assertions.Assertions.assertThat;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class GroupMembershipFinderTest {
+
+ @Mock
+ UserDao userDao;
+
+ @Mock
+ GroupMembershipDao groupMembershipDao;
+
+ GroupMembershipFinder finder;
+
+ @Before
+ public void setUp() throws Exception {
+ when(userDao.selectActiveUserByLogin("arthur")).thenReturn(new UserDto().setId(100L).setName("arthur"));
+ finder = new GroupMembershipFinder(userDao, groupMembershipDao);
+ }
+
+ @Test
+ public void find() throws Exception {
+ GroupMembershipQuery query = GroupMembershipQuery.builder().login("arthur").build();
+ when(groupMembershipDao.selectGroups(eq(query), anyLong(), anyInt(), anyInt())).thenReturn(
+ newArrayList(new GroupMembershipDto().setId(1L).setName("users"))
+ );
+
+ GroupMembershipQueryResult result = finder.find(query);
+ assertThat(result.groups()).hasSize(1);
+ assertThat(result.hasMoreResults()).isFalse();
+ }
+
+ @Test
+ public void find_with_paging() throws Exception {
+ GroupMembershipQuery query = GroupMembershipQuery.builder().login("arthur").pageIndex(3).pageSize(10).build();
+ finder.find(query);
+
+ ArgumentCaptor<Integer> argumentOffset = ArgumentCaptor.forClass(Integer.class);
+ ArgumentCaptor<Integer> argumentLimit = ArgumentCaptor.forClass(Integer.class);
+ verify(groupMembershipDao).selectGroups(eq(query), anyLong(), argumentOffset.capture(), argumentLimit.capture());
+
+ assertThat(argumentOffset.getValue()).isEqualTo(20);
+ assertThat(argumentLimit.getValue()).isEqualTo(11);
+ }
+
+ @Test
+ public void find_with_paging_having_more_results() throws Exception {
+ GroupMembershipQuery query = GroupMembershipQuery.builder().login("arthur").pageIndex(1).pageSize(2).build();
+ when(groupMembershipDao.selectGroups(eq(query), anyLong(), anyInt(), anyInt())).thenReturn(newArrayList(
+ new GroupMembershipDto().setId(1L).setName("group1"),
+ new GroupMembershipDto().setId(2L).setName("group2"),
+ new GroupMembershipDto().setId(3L).setName("group3"))
+ );
+ GroupMembershipQueryResult result = finder.find(query);
+
+ ArgumentCaptor<Integer> argumentOffset = ArgumentCaptor.forClass(Integer.class);
+ ArgumentCaptor<Integer> argumentLimit = ArgumentCaptor.forClass(Integer.class);
+ verify(groupMembershipDao).selectGroups(eq(query), anyLong(), argumentOffset.capture(), argumentLimit.capture());
+
+ assertThat(argumentOffset.getValue()).isEqualTo(0);
+ assertThat(argumentLimit.getValue()).isEqualTo(3);
+ assertThat(result.hasMoreResults()).isTrue();
+ }
+
+ @Test
+ public void find_with_paging_having_no_more_results() throws Exception {
+ GroupMembershipQuery query = GroupMembershipQuery.builder().login("arthur").pageIndex(1).pageSize(10).build();
+ when(groupMembershipDao.selectGroups(eq(query), anyLong(), anyInt(), anyInt())).thenReturn(newArrayList(
+ new GroupMembershipDto().setId(1L).setName("group1"),
+ new GroupMembershipDto().setId(2L).setName("group2"),
+ new GroupMembershipDto().setId(3L).setName("group3"),
+ new GroupMembershipDto().setId(4L).setName("group4"))
+ );
+ GroupMembershipQueryResult result = finder.find(query);
+
+ ArgumentCaptor<Integer> argumentOffset = ArgumentCaptor.forClass(Integer.class);
+ ArgumentCaptor<Integer> argumentLimit = ArgumentCaptor.forClass(Integer.class);
+ verify(groupMembershipDao).selectGroups(eq(query), anyLong(), argumentOffset.capture(), argumentLimit.capture());
+
+ assertThat(argumentOffset.getValue()).isEqualTo(0);
+ assertThat(argumentLimit.getValue()).isEqualTo(11);
+ assertThat(result.hasMoreResults()).isFalse();
+ }
+}
public void before() throws Exception {
GroupMembershipDao groupMembershipDao = new GroupMembershipDao(getMyBatis());
UserDao userDao = new UserDao(getMyBatis());
- service = new InternalGroupMembershipQueryService(userDao, groupMembershipDao);
+ GroupMembershipFinder finder = new GroupMembershipFinder(userDao, groupMembershipDao);
+ service = new InternalGroupMembershipQueryService(finder);
}
@Test
public void find_all_member_groups() {
setupData("shared");
- List<GroupMembership> result = service.find(ImmutableMap.of(
- "user", "user1",
+ GroupMembershipQueryResult queryResult = service.find(ImmutableMap.<String, Object>of(
+ "login", "user1",
"selected", "all"));
+ List<GroupMembership> result = queryResult.groups();
assertThat(result).hasSize(3);
check(result.get(0), "sonar-administrators", false);
check(result.get(1), "sonar-reviewers", false);
public void find_all_member_groups_when_no_selected_parameter() {
setupData("shared");
- List<GroupMembership> result = service.find(ImmutableMap.of(
- "user", "user1"));
+ GroupMembershipQueryResult queryResult = service.find(ImmutableMap.<String, Object>of(
+ "login", "user1"));
+ List<GroupMembership> result = queryResult.groups();
assertThat(result).hasSize(3);
check(result.get(0), "sonar-administrators", false);
check(result.get(1), "sonar-reviewers", false);
public void find_member_groups() {
setupData("shared");
- List<GroupMembership> result = service.find(ImmutableMap.of(
- "user", "user1",
+ GroupMembershipQueryResult queryResult = service.find(ImmutableMap.<String, Object>of(
+ "login", "user1",
"selected", "selected"));
+ List<GroupMembership> result = queryResult.groups();
assertThat(result).hasSize(1);
check(result.get(0), "sonar-users", true);
}
public void find_not_member_groups() {
setupData("shared");
- List<GroupMembership> result = service.find(ImmutableMap.of(
- "user", "user1",
+ GroupMembershipQueryResult queryResult = service.find(ImmutableMap.<String, Object>of(
+ "login", "user1",
"selected", "deselected"));
+ List<GroupMembership> result = queryResult.groups();
assertThat(result).hasSize(2);
check(result.get(0), "sonar-administrators", false);
check(result.get(1), "sonar-reviewers", false);
}
+ @Test
+ public void find_with_paging_with_more_results() {
+ setupData("shared");
+
+ GroupMembershipQueryResult queryResult = service.find(ImmutableMap.<String, Object>of(
+ "login", "user1",
+ "selected", "all",
+ "page", 1,
+ "pageSize", 2
+ ));
+ List<GroupMembership> result = queryResult.groups();
+ assertThat(result).hasSize(2);
+ assertThat(queryResult.hasMoreResults()).isTrue();
+ }
+
+ @Test
+ public void find_with_paging_with_no_more_results() {
+ setupData("shared");
+
+ GroupMembershipQueryResult queryResult = service.find(ImmutableMap.<String, Object>of(
+ "login", "user1",
+ "selected", "all",
+ "page", 3,
+ "pageSize", 1
+ ));
+ List<GroupMembership> result = queryResult.groups();
+ assertThat(result).hasSize(1);
+ assertThat(queryResult.hasMoreResults()).isFalse();
+ }
+
@Test
public void fail_if_user_not_found() {
setupData("shared");
try {
- service.find(ImmutableMap.of(
- "user", "user_not_existing",
+ service.find(ImmutableMap.<String, Object>of(
+ "login", "user_not_existing",
"selected", "all"));
fail();
} catch (Exception e) {
public void find_matched_groups_name() {
setupData("shared");
- List<GroupMembership> result = service.find(ImmutableMap.of(
- "user", "user1",
+ GroupMembershipQueryResult queryResult = service.find(ImmutableMap.<String, Object>of(
+ "login", "user1",
"selected", "all",
"query", "user"));
+ List<GroupMembership> result = queryResult.groups();
assertThat(result).hasSize(1);
check(result.get(0), "sonar-users", true);
- result = service.find(ImmutableMap.of(
- "user", "user1",
+ queryResult = service.find(ImmutableMap.<String, Object>of(
+ "login", "user1",
"selected", "all",
"query", "sonar"));
+ result = queryResult.groups();
assertThat(result).hasSize(3);
}
projects / sonarqube.git / commitdiff