return issueService.getByKey(issueKey);
}
- public Map<String, Long> findIssueAssignees(Map<String, Object> params) {
- return issueService.findIssueAssignees(issueQueryService.createFromMap(params));
- }
-
public List<Transition> listTransitions(String issueKey) {
return issueService.listTransitions(issueKey);
}
import java.util.*;
-import static com.google.common.collect.Maps.newLinkedHashMap;
-
public class IssueService implements ServerComponent {
private final DbClient dbClient;
return aggregation;
}
- public Map<String, Long> findIssueAssignees(IssueQuery query) {
- Map<String, Long> result = newLinkedHashMap();
- Map<String,Long> buckets = issueIndex.searchForAssignees(query);
- for (Map.Entry<String, Long> bucket : buckets.entrySet()) {
- if ("_notAssigned_".equals(bucket.getKey())) {
- // TODO null key ?
- result.put(null, bucket.getValue());
- } else {
- result.put(bucket.getKey(), bucket.getValue());
- }
- }
- return result;
- }
-
public Issue getByKey(String key) {
return issueIndex.getByKey(key);
}
import org.elasticsearch.search.aggregations.bucket.global.Global;
import org.elasticsearch.search.aggregations.bucket.global.GlobalBuilder;
import org.elasticsearch.search.aggregations.bucket.histogram.DateHistogram;
-import org.elasticsearch.search.aggregations.bucket.missing.InternalMissing;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.bucket.terms.TermsBuilder;
import org.elasticsearch.search.aggregations.metrics.min.Min;
getClient().prepareDeleteByQuery(IssueIndexDefinition.INDEX).setQuery(queryBuilder).get();
}
- public LinkedHashMap<String, Long> searchForAssignees(IssueQuery query) {
- // TODO do not return hits
- // TODO what's max size ?
-
- SearchRequestBuilder esSearch = getClient()
- .prepareSearch(IssueIndexDefinition.INDEX)
- .setTypes(IssueIndexDefinition.TYPE_ISSUE);
-
- QueryBuilder esQuery = QueryBuilders.matchAllQuery();
- BoolFilterBuilder esFilter = createBoolFilter(query);
- if (esFilter.hasClauses()) {
- esSearch.setQuery(QueryBuilders.filteredQuery(esQuery, esFilter));
- } else {
- esSearch.setQuery(esQuery);
- }
- esSearch.addAggregation(AggregationBuilders.terms(IssueIndexDefinition.FIELD_ISSUE_ASSIGNEE)
- .size(Integer.MAX_VALUE)
- .field(IssueIndexDefinition.FIELD_ISSUE_ASSIGNEE));
- esSearch.addAggregation(AggregationBuilders.missing("notAssigned")
- .field(IssueIndexDefinition.FIELD_ISSUE_ASSIGNEE));
-
- SearchResponse response = esSearch.get();
- Terms aggregation = (Terms) response.getAggregations().getAsMap().get(IssueIndexDefinition.FIELD_ISSUE_ASSIGNEE);
- LinkedHashMap<String, Long> result = EsUtils.termsToMap(aggregation);
- result.put("_notAssigned_", ((InternalMissing) response.getAggregations().get("notAssigned")).getDocCount());
- return result;
- }
-
private BoolFilterBuilder createBoolFilter(IssueQuery query) {
BoolFilterBuilder boolFilter = FilterBuilders.boolFilter();
for (FilterBuilder filter : createFilters(query).values()) {
QueryContext options = new QueryContext();
Integer pageSize = RubyUtils.toInteger(params.get("pageSize"));
int size = pageSize != null ? pageSize : 50;
- if (size > -1) {
- Integer page = RubyUtils.toInteger(params.get("p"));
- int pageIndex = page != null ? page : 1;
- options.setPage(pageIndex, size);
- Result<Rule> result = service.search(query, options);
- return new PagedResult<Rule>(result.getHits(), PagingResult.create(options.getLimit(), pageIndex, result.getTotal()));
- } else {
- options = new QueryContext().setScroll(true);
- List<Rule> rules = newArrayList(service.search(query, options).scroll());
- return new PagedResult<Rule>(rules, PagingResult.create(Integer.MAX_VALUE, 1, rules.size()));
- }
+ Integer page = RubyUtils.toInteger(params.get("p"));
+ int pageIndex = page != null ? page : 1;
+ options.setPage(pageIndex, size);
+ Result<Rule> result = service.search(query, options);
+ return new PagedResult<Rule>(result.getHits(), PagingResult.create(options.getLimit(), pageIndex, result.getTotal()));
}
/**
return service.search(new RuleQuery().setRepositories(newArrayList(RuleDoc.MANUAL_REPOSITORY)).setSortField(RuleNormalizer.RuleField.NAME), new QueryContext()).getHits();
}
-
// sqale
public void updateRule(Map<String, Object> params) {
RuleUpdate update = RuleUpdate.createForPluginRule(RuleKey.parse((String) params.get("ruleKey")));
update.setDebtRemediationFunction(null);
} else {
update.setDebtRemediationFunction(new DefaultDebtRemediationFunction(
- DebtRemediationFunction.Type.valueOf(fn),
- Strings.emptyToNull((String) params.get("debtRemediationCoefficient")),
- Strings.emptyToNull((String) params.get("debtRemediationOffset")))
- );
+ DebtRemediationFunction.Type.valueOf(fn),
+ Strings.emptyToNull((String) params.get("debtRemediationCoefficient")),
+ Strings.emptyToNull((String) params.get("debtRemediationOffset")))
+ );
}
updater.update(update, UserSession.get());
}
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.*;
public class InternalRubyIssueServiceTest {
verify(issueService).getByKey("ABCD");
}
- @Test
- public void find_issue_assignees() throws Exception {
- service.findIssueAssignees(ImmutableMap.<String, Object>of("issues", "ABCD"));
- verify(issueService).findIssueAssignees(any(IssueQuery.class));
- }
-
@Test
public void list_transitions_by_issue_key() throws Exception {
service.listTransitions("ABCD");
*/
package org.sonar.server.issue;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterators;
-import com.google.common.collect.Multiset;
-import com.google.common.collect.Sets;
+import com.google.common.collect.*;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
-import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.entry;
assertThat(result).hasSize(1);
}
- @Test
- public void find_issue_assignees() throws Exception {
- RuleDto rule = newRule();
- ComponentDto project = newProject();
- ComponentDto file = newFile(project);
- saveIssue(IssueTesting.newDto(rule, file, project).setAssignee("steph"));
- saveIssue(IssueTesting.newDto(rule, file, project).setAssignee("simon"));
- saveIssue(IssueTesting.newDto(rule, file, project));
- saveIssue(IssueTesting.newDto(rule, file, project).setAssignee("steph"));
-
- Map<String, Long> results = service.findIssueAssignees(IssueQuery.builder().build());
-
- assertThat(results).hasSize(3);
- assertThat(results.get("steph")).isEqualTo(2L);
- assertThat(results.get("simon")).isEqualTo(1L);
- assertThat(results.get(null)).isEqualTo(1L);
-
- assertThat(results.keySet().toArray()[0]).isEqualTo("steph");
- assertThat(results.keySet().toArray()[1]).isEqualTo("simon");
- assertThat(results.keySet().toArray()[2]).isNull();
- }
-
@Test
public void list_tags() {
RuleDto rule = newRule();
import javax.annotation.Nullable;
-import java.util.*;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
import static com.google.common.collect.Lists.newArrayList;
import static org.assertj.core.api.Assertions.*;
assertThat(index.search(IssueQuery.builder().build(), new SearchOptions()).getDocs()).hasSize(1);
}
- @Test
- public void list_assignees() throws Exception {
- ComponentDto project = ComponentTesting.newProjectDto();
- ComponentDto file = ComponentTesting.newFileDto(project);
-
- indexIssues(
- IssueTesting.newDoc("ISSUE1", file).setAssignee("steph").setStatus(Issue.STATUS_OPEN),
- IssueTesting.newDoc("ISSUE2", file).setAssignee("simon").setStatus(Issue.STATUS_OPEN),
- IssueTesting.newDoc("ISSUE3", file).setAssignee(null).setStatus(Issue.STATUS_OPEN),
- IssueTesting.newDoc("ISSUE4", file).setAssignee("steph").setStatus(Issue.STATUS_OPEN),
- // Issue assigned to julien should not be returned as the issue is closed
- IssueTesting.newDoc("ISSUE5", file).setAssignee("julien").setStatus(Issue.STATUS_CLOSED));
-
- LinkedHashMap<String, Long> results = index.searchForAssignees(IssueQuery.builder().statuses(newArrayList(Issue.STATUS_OPEN)).build());
- assertThat(results).hasSize(3);
-
- Iterator<Map.Entry<String, Long>> buckets = results.entrySet().iterator();
-
- Map.Entry<String, Long> bucket = buckets.next();
- assertThat(bucket.getKey()).isEqualTo("steph");
- assertThat(bucket.getValue()).isEqualTo(2L);
-
- bucket = buckets.next();
- assertThat(bucket.getKey()).isEqualTo("simon");
- assertThat(bucket.getValue()).isEqualTo(1L);
-
- bucket = buckets.next();
- assertThat(bucket.getKey()).isEqualTo("_notAssigned_");
- assertThat(bucket.getValue()).isEqualTo(1L);
- }
-
@Test
public void delete_closed_issues_from_one_project_older_than_specific_date() {
// ARRANGE
import org.mockito.runners.MockitoJUnitRunner;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.rule.RuleStatus;
-import org.sonar.server.paging.PagedResult;
import org.sonar.server.rule.index.RuleQuery;
import org.sonar.server.search.QueryContext;
import org.sonar.server.search.Result;
import org.sonar.server.user.UserSession;
import java.util.HashMap;
-import java.util.List;
-import static com.google.common.collect.Lists.newArrayList;
import static com.google.common.collect.Maps.newHashMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Matchers.any;
assertThat(optionsCaptor.getValue().getOffset()).isEqualTo(0);
}
- @Test
- public void search_all_rules() throws Exception {
- List<Rule> rules = newArrayList(mock(Rule.class));
- Result serviceResult = mock(Result.class);
- when(serviceResult.scroll()).thenReturn(rules.iterator());
-
- when(ruleService.search(any(RuleQuery.class), any(QueryContext.class))).thenReturn(serviceResult);
-
- HashMap<String, Object> params = newHashMap();
- params.put("pageSize", "-1");
- PagedResult<Rule> result = service.find(params);
-
- verify(serviceResult).scroll();
-
- verify(ruleService).search(ruleQueryCaptor.capture(), optionsCaptor.capture());
- assertThat(result.paging().pageSize()).isEqualTo(Integer.MAX_VALUE);
- }
-
@Test
public void update_rule() throws Exception {
when(ruleService.search(any(RuleQuery.class), any(QueryContext.class))).thenReturn(mock(Result.class));
projects / sonarqube.git / commitdiff