import org.sonar.server.activity.index.ActivityQuery;
import org.sonar.server.db.DbClient;
import org.sonar.server.search.IndexClient;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.search.Result;
import org.sonar.server.user.UserSession;
return new ActivityQuery();
}
- public Result<Activity> search(ActivityQuery query, QueryOptions options) {
+ public Result<Activity> search(ActivityQuery query, QueryContext options) {
ActivityIndex index = indexClient.get(ActivityIndex.class);
return new Result<Activity>(index, index.search(query, options));
}
import org.sonar.server.qualityprofile.QProfileActivity;
import org.sonar.server.qualityprofile.QProfileActivityQuery;
import org.sonar.server.qualityprofile.QProfileService;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.search.Result;
import org.sonar.server.util.RubyUtils;
*/
public QProfileActivityResult search(Map<String, Object> params) {
QProfileActivityQuery query = new QProfileActivityQuery();
- QueryOptions queryOptions = new QueryOptions().setMaxLimit();
+ QueryContext queryContext = new QueryContext().setMaxLimit();
List<String> profileKeys = RubyUtils.toStrings(params.get("profileKeys"));
if (profileKeys != null) {
query.setQprofileKeys(profileKeys);
}
Integer page = RubyUtils.toInteger(params.get("p"));
int pageIndex = page != null ? page : 1;
- queryOptions.setPage(pageIndex, 50);
+ queryContext.setPage(pageIndex, 50);
- Result<QProfileActivity> result = service.searchActivities(query, queryOptions);
- return new QProfileActivityResult(result.getHits(), Paging.create(queryOptions.getLimit(), pageIndex, Long.valueOf(result.getTotal()).intValue()));
+ Result<QProfileActivity> result = service.searchActivities(query, queryContext);
+ return new QProfileActivityResult(result.getHits(), Paging.create(queryContext.getLimit(), pageIndex, Long.valueOf(result.getTotal()).intValue()));
}
@Override
import org.elasticsearch.common.settings.ImmutableSettings;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.unit.TimeValue;
-import org.elasticsearch.index.query.AndFilterBuilder;
-import org.elasticsearch.index.query.FilterBuilder;
-import org.elasticsearch.index.query.FilterBuilders;
-import org.elasticsearch.index.query.OrFilterBuilder;
-import org.elasticsearch.index.query.QueryBuilders;
+import org.elasticsearch.index.query.*;
import org.elasticsearch.search.sort.SortOrder;
import org.sonar.core.activity.Activity;
import org.sonar.core.activity.db.ActivityDto;
-import org.sonar.server.search.BaseIndex;
-import org.sonar.server.search.IndexDefinition;
-import org.sonar.server.search.IndexField;
-import org.sonar.server.search.QueryOptions;
-import org.sonar.server.search.Result;
-import org.sonar.server.search.SearchClient;
+import org.sonar.server.search.*;
import javax.annotation.Nullable;
+
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
return new Result<Activity>(this, response);
}
- public SearchResponse search(ActivityQuery query, QueryOptions options) {
+ public SearchResponse search(ActivityQuery query, QueryContext options) {
return search(query, options, null);
}
- public SearchResponse search(ActivityQuery query, QueryOptions options,
+ public SearchResponse search(ActivityQuery query, QueryContext options,
@Nullable FilterBuilder domainFilter) {
// Prepare query
import org.sonar.core.activity.Activity;
import org.sonar.server.activity.ActivityService;
import org.sonar.server.activity.index.ActivityQuery;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.search.Result;
import org.sonar.server.search.ws.SearchOptions;
public void handle(Request request, Response response) {
ActivityQuery query = logService.newActivityQuery();
SearchOptions searchOptions = SearchOptions.create(request);
- QueryOptions queryOptions = mapping.newQueryOptions(searchOptions);
+ QueryContext queryContext = mapping.newQueryOptions(searchOptions);
- Result<Activity> results = logService.search(query, queryOptions);
+ Result<Activity> results = logService.search(query, queryContext);
JsonWriter json = response.newJsonWriter().beginObject();
searchOptions.writeStatistics(json, results);
import org.sonar.server.rule.RuleService;
import org.sonar.server.rule.index.RuleDoc;
import org.sonar.server.rule.index.RuleQuery;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.search.Result;
import org.sonar.server.ui.ViewProxy;
import org.sonar.server.ui.Views;
}
private void appendManualRules(JsonWriter json) {
- Result<Rule> result = ruleService.search(new RuleQuery().setRepositories(newArrayList(RuleDoc.MANUAL_REPOSITORY)), new QueryOptions().setMaxLimit());
+ Result<Rule> result = ruleService.search(new RuleQuery().setRepositories(newArrayList(RuleDoc.MANUAL_REPOSITORY)), new QueryContext().setMaxLimit());
if (result != null && !result.getHits().isEmpty()) {
List<Rule> manualRules = result.getHits();
json.name("manual_rules").beginArray();
import org.sonar.server.issue.index.IssueResult;
import org.sonar.server.rule.index.RuleIndex;
import org.sonar.server.search.IndexClient;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.user.UserSession;
import javax.annotation.Nullable;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Date;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
/**
* @since 3.6
return indexClient.get(IssueIndex.class).getByKey(key);
}
- public IssueResult search(IssueQuery query, QueryOptions options) {
+ public IssueResult search(IssueQuery query, QueryContext options) {
IssueIndex issueIndex = indexClient.get(IssueIndex.class);
import com.google.common.collect.ImmutableList;
import org.apache.ibatis.session.ResultContext;
import org.apache.ibatis.session.ResultHandler;
+import org.sonar.api.security.DefaultGroups;
import org.sonar.api.utils.System2;
import org.sonar.api.web.UserRole;
import org.sonar.core.issue.db.IssueAuthorizationDto;
Map<String, Object> params = newHashMap();
params.put("date", date);
params.put("permission", UserRole.USER);
+ params.put("anyone", DefaultGroups.ANYONE);
Map<String, IssueAuthorizationDto> authorizationDtoMap = newHashMap();
protected Map getSynchronizationParams(Date date) {
Map<String, Object> params = super.getSynchronizationParams(date);
params.put("permission", UserRole.USER);
+ params.put("anyone", DefaultGroups.ANYONE);
return params;
}
}
import org.elasticsearch.common.settings.ImmutableSettings;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.unit.TimeValue;
-import org.elasticsearch.index.query.BoolFilterBuilder;
-import org.elasticsearch.index.query.FilterBuilders;
-import org.elasticsearch.index.query.QueryBuilder;
-import org.elasticsearch.index.query.QueryBuilders;
+import org.elasticsearch.index.query.*;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.sonar.api.issue.IssueQuery;
+import org.sonar.api.web.UserRole;
import org.sonar.core.issue.db.IssueDto;
-import org.sonar.server.search.BaseIndex;
-import org.sonar.server.search.IndexDefinition;
-import org.sonar.server.search.IndexField;
-import org.sonar.server.search.QueryOptions;
-import org.sonar.server.search.SearchClient;
+import org.sonar.server.search.*;
import java.io.IOException;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
+import java.util.Set;
public class IssueIndex extends BaseIndex<IssueDoc, IssueDto, String> {
return new IssueDoc(fields);
}
- public SearchResponse search(IssueQuery query, QueryOptions options) {
+ public SearchResponse search(IssueQuery query, QueryContext options) {
SearchRequestBuilder esSearch = getClient()
.prepareSearch(this.getIndexName())
BoolFilterBuilder esFilter = FilterBuilders.boolFilter();
+ // Authorization
+ String user = options.getUserLogin();
+ Set<String> groups = options.getUserGroups();
+ OrFilterBuilder groupsAndUser = FilterBuilders.orFilter();
+ if (user != null) {
+ groupsAndUser.add(FilterBuilders.termFilter(IssueAuthorizationNormalizer.IssueAuthorizationField.USERS.field(), user));
+ }
+ for (String group : groups) {
+ groupsAndUser.add(FilterBuilders.termFilter(IssueAuthorizationNormalizer.IssueAuthorizationField.GROUPS.field(), group));
+ }
+ esFilter.must(FilterBuilders.hasParentFilter(IndexDefinition.ISSUES_AUTHORIZATION.getIndexType(),
+ QueryBuilders.filteredQuery(
+ QueryBuilders.matchAllQuery(),
+ FilterBuilders.boolFilter()
+ .must(FilterBuilders.termFilter(IssueAuthorizationNormalizer.IssueAuthorizationField.PERMISSION.field(), UserRole.USER), groupsAndUser)
+ .cache(true))
+ ));
+
// Issue is assigned Filter
if (query.assigned() != null && query.assigned()) {
esFilter.must(FilterBuilders.existsFilter(IssueNormalizer.IssueField.ASSIGNEE.field()));
import com.google.common.io.Resources;
import org.sonar.api.component.Component;
import org.sonar.api.i18n.I18n;
-import org.sonar.api.issue.ActionPlan;
-import org.sonar.api.issue.Issue;
-import org.sonar.api.issue.IssueComment;
-import org.sonar.api.issue.IssueQuery;
-import org.sonar.api.issue.IssueQueryResult;
+import org.sonar.api.issue.*;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.rule.Severity;
import org.sonar.api.rules.Rule;
import org.sonar.server.issue.filter.IssueFilterParameters;
import org.sonar.server.issue.index.IssueResult;
import org.sonar.server.search.FacetValue;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.search.Result;
import org.sonar.server.search.ws.SearchOptions;
import org.sonar.server.user.UserSession;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Date;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
import static com.google.common.collect.Lists.newArrayList;
public void handle(Request request, Response response) {
IssueQuery query = createQuery(request);
SearchOptions searchOptions = SearchOptions.create(request);
- QueryOptions queryOptions = new QueryOptions();
- queryOptions.setPage(searchOptions.page(), searchOptions.pageSize());
- queryOptions.setFacet(request.mandatoryParamAsBoolean(PARAM_FACETS));
+ QueryContext queryContext = new QueryContext();
+ queryContext.setPage(searchOptions.page(), searchOptions.pageSize());
+ queryContext.setFacet(request.mandatoryParamAsBoolean(PARAM_FACETS));
- IssueResult results = service.search(query, queryOptions);
+ IssueResult results = service.search(query, queryContext);
JsonWriter json = response.newJsonWriter();
json.beginObject();
// writeUsers(results, json);
// writeActionPlans(results, json);
- if (queryOptions.isFacet()) {
+ if (queryContext.isFacet()) {
writeFacets(results, json);
}
import org.sonar.server.rule.index.RuleQuery;
import org.sonar.server.search.FacetValue;
import org.sonar.server.search.IndexClient;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import javax.annotation.CheckForNull;
+
import java.util.HashMap;
import java.util.List;
import java.util.Map;
.setQProfileKey(key)
.setActivation(true)
.setStatuses(Lists.newArrayList(RuleStatus.DEPRECATED)),
- new QueryOptions().setLimit(0)).getTotal();
+ new QueryContext().setLimit(0)).getTotal();
}
import org.sonar.server.db.DbClient;
import org.sonar.server.rule.index.RuleQuery;
import org.sonar.server.search.IndexClient;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.search.Result;
import org.sonar.server.user.UserSession;
UserSession.get().checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
}
- public Result<QProfileActivity> searchActivities(QProfileActivityQuery query, QueryOptions options) {
+ public Result<QProfileActivity> searchActivities(QProfileActivityQuery query, QueryContext options) {
DbSession session = db.openSession(false);
try {
OrFilterBuilder activityFilter = FilterBuilders.orFilter();
import com.google.common.base.Splitter;
import com.google.common.collect.Lists;
-import org.apache.commons.lang.StringUtils;
import org.sonar.api.ServerComponent;
import org.sonar.api.server.rule.RuleParamType;
import org.sonar.core.activity.Activity;
import org.sonar.server.rule.index.RuleNormalizer;
import org.sonar.server.rule.index.RuleQuery;
import org.sonar.server.search.IndexClient;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.search.Result;
import org.sonar.server.util.TypeValidations;
RuleIndex ruleIndex = index.get(RuleIndex.class);
DbSession dbSession = db.openSession(false);
try {
- Result<Rule> ruleSearchResult = ruleIndex.search(ruleQuery, new QueryOptions().setScroll(true)
+ Result<Rule> ruleSearchResult = ruleIndex.search(ruleQuery, new QueryContext().setScroll(true)
.setFieldsToReturn(Arrays.asList(RuleNormalizer.RuleField.KEY.field())));
Iterator<Rule> rules = ruleSearchResult.scroll();
while (rules.hasNext()) {
try {
RuleIndex ruleIndex = index.get(RuleIndex.class);
BulkChangeResult result = new BulkChangeResult();
- Result<Rule> ruleSearchResult = ruleIndex.search(ruleQuery, new QueryOptions().setScroll(true)
+ Result<Rule> ruleSearchResult = ruleIndex.search(ruleQuery, new QueryContext().setScroll(true)
.setFieldsToReturn(Arrays.asList(RuleNormalizer.RuleField.KEY.field())));
Iterator<Rule> rules = ruleSearchResult.scroll();
while (rules.hasNext()) {
import org.sonar.server.rule.index.RuleIndex;
import org.sonar.server.rule.index.RuleQuery;
import org.sonar.server.search.IndexClient;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.search.Result;
import javax.annotation.CheckForNull;
}
public final org.sonar.api.rules.Rule find(org.sonar.api.rules.RuleQuery query) {
- Result<Rule> result = index.search(toQuery(query), new QueryOptions());
+ Result<Rule> result = index.search(toQuery(query), new QueryContext());
if (!result.getHits().isEmpty()) {
return toRule(result.getHits().get(0));
} else {
public final Collection<org.sonar.api.rules.Rule> findAll(org.sonar.api.rules.RuleQuery query) {
List<org.sonar.api.rules.Rule> rules = newArrayList();
- for (Rule rule : index.search(toQuery(query), new QueryOptions()).getHits()) {
+ for (Rule rule : index.search(toQuery(query), new QueryContext()).getHits()) {
rules.add(toRule(rule));
}
return rules;
import org.sonar.server.rule.index.RuleDoc;
import org.sonar.server.rule.index.RuleNormalizer;
import org.sonar.server.rule.index.RuleQuery;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.search.Result;
import org.sonar.server.user.UserSession;
import org.sonar.server.util.RubyUtils;
query.setHasDebtCharacteristic(RubyUtils.toBoolean(params.get("hasDebtCharacteristic")));
query.setSortField(RuleNormalizer.RuleField.NAME);
- QueryOptions options = new QueryOptions();
+ QueryContext options = new QueryContext();
Integer pageSize = RubyUtils.toInteger(params.get("pageSize"));
int size = pageSize != null ? pageSize : 50;
if (size > -1) {
Result<Rule> result = service.search(query, options);
return new PagedResult<Rule>(result.getHits(), PagingResult.create(options.getLimit(), pageIndex, result.getTotal()));
} else {
- options = new QueryOptions().setScroll(true);
+ 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()));
}
* Used in manual_rules_controller.rb
*/
public List<Rule> searchManualRules() {
- return service.search(new RuleQuery().setRepositories(newArrayList(RuleDoc.MANUAL_REPOSITORY)).setSortField(RuleNormalizer.RuleField.NAME), new QueryOptions()).getHits();
+ return service.search(new RuleQuery().setRepositories(newArrayList(RuleDoc.MANUAL_REPOSITORY)).setSortField(RuleNormalizer.RuleField.NAME), new QueryContext()).getHits();
}
import org.sonar.server.rule.index.RuleIndex;
import org.sonar.server.rule.index.RuleNormalizer;
import org.sonar.server.rule.index.RuleQuery;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.search.Result;
import org.sonar.server.user.UserSession;
return new RuleQuery();
}
- public Result<Rule> search(RuleQuery query, QueryOptions options) {
+ public Result<Rule> search(RuleQuery query, QueryContext options) {
return index.search(query, options);
}
import org.elasticsearch.common.settings.ImmutableSettings;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.unit.TimeValue;
-import org.elasticsearch.index.query.BoolFilterBuilder;
-import org.elasticsearch.index.query.BoolQueryBuilder;
-import org.elasticsearch.index.query.FilterBuilder;
-import org.elasticsearch.index.query.FilterBuilders;
-import org.elasticsearch.index.query.MatchQueryBuilder;
-import org.elasticsearch.index.query.QueryBuilder;
-import org.elasticsearch.index.query.QueryBuilders;
-import org.elasticsearch.index.query.SimpleQueryStringBuilder;
+import org.elasticsearch.index.query.*;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.sonar.core.rule.RuleDto;
import org.sonar.server.qualityprofile.index.ActiveRuleNormalizer;
import org.sonar.server.rule.Rule;
-import org.sonar.server.search.BaseIndex;
-import org.sonar.server.search.IndexDefinition;
-import org.sonar.server.search.IndexField;
-import org.sonar.server.search.QueryOptions;
-import org.sonar.server.search.Result;
-import org.sonar.server.search.SearchClient;
+import org.sonar.server.search.*;
import javax.annotation.CheckForNull;
+
import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
import static com.google.common.collect.Lists.newArrayList;
return mapping;
}
- private void setFields(QueryOptions options, SearchRequestBuilder esSearch) {
+ private void setFields(QueryContext options, SearchRequestBuilder esSearch) {
/* integrate Option's Fields */
Set<String> fields = new HashSet<String>();
if (!options.getFieldsToReturn().isEmpty()) {
esSearch.setFetchSource(fields.toArray(new String[fields.size()]), null);
}
- private void setFacets(QueryOptions options, SearchRequestBuilder esSearch) {
+ private void setFacets(QueryContext options, SearchRequestBuilder esSearch) {
/* Integrate Facets */
if (options.isFacet()) {
this.setFacets(esSearch);
}
}
- protected void setPagination(QueryOptions options, SearchRequestBuilder esSearch) {
+ protected void setPagination(QueryContext options, SearchRequestBuilder esSearch) {
esSearch.setFrom(options.getOffset());
esSearch.setSize(options.getLimit());
}
}
/* Build main query (search based) */
- protected QueryBuilder getQuery(RuleQuery query, QueryOptions options) {
+ protected QueryBuilder getQuery(RuleQuery query, QueryContext options) {
// No contextual query case
String queryText = query.getQueryText();
}
/* Build main filter (match based) */
- protected FilterBuilder getFilter(RuleQuery query, QueryOptions options) {
+ protected FilterBuilder getFilter(RuleQuery query, QueryContext options) {
BoolFilterBuilder fb = FilterBuilders.boolFilter();
}
- public Result<Rule> search(RuleQuery query, QueryOptions options) {
+ public Result<Rule> search(RuleQuery query, QueryContext options) {
SearchRequestBuilder esSearch = getClient()
.prepareSearch(this.getIndexName())
.setTypes(this.getIndexType())
import org.sonar.server.rule.index.RuleNormalizer;
import org.sonar.server.rule.index.RuleQuery;
import org.sonar.server.search.FacetValue;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.search.Result;
import org.sonar.server.search.ws.SearchOptions;
public void handle(Request request, Response response) {
RuleQuery query = createRuleQuery(ruleService.newRuleQuery(), request);
SearchOptions searchOptions = SearchOptions.create(request);
- QueryOptions queryOptions = mapping.newQueryOptions(searchOptions);
- queryOptions.setFacet(request.mandatoryParamAsBoolean(PARAM_FACETS));
+ QueryContext queryContext = mapping.newQueryOptions(searchOptions);
+ queryContext.setFacet(request.mandatoryParamAsBoolean(PARAM_FACETS));
- Result<Rule> results = ruleService.search(query, queryOptions);
+ Result<Rule> results = ruleService.search(query, queryContext);
JsonWriter json = response.newJsonWriter().beginObject();
searchOptions.writeStatistics(json, results);
if (searchOptions.hasField("actives")) {
activeRuleCompleter.completeSearch(query, results.getHits(), json);
}
- if (queryOptions.isFacet()) {
+ if (queryContext.isFacet()) {
writeFacets(results, json);
}
json.endObject().close();
--- /dev/null
+/*
+ * SonarQube, open source software quality management tool.
+ * Copyright (C) 2008-2014 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.search;
+
+import com.google.common.base.Preconditions;
+import org.sonar.server.user.UserSession;
+
+import javax.annotation.Nullable;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Set;
+
+import static com.google.common.collect.Sets.newHashSet;
+
+/**
+ * Various Elasticsearch request options: paging, sorting, fields and facets
+ *
+ * @since 4.4
+ */
+public class QueryContext {
+
+ public static final int DEFAULT_OFFSET = 0;
+ public static final int DEFAULT_LIMIT = 10;
+ public static final int MAX_LIMIT = 500;
+ public static final boolean DEFAULT_FACET = false;
+
+ private int offset = DEFAULT_OFFSET;
+ private int limit = DEFAULT_LIMIT;
+ private boolean facet = DEFAULT_FACET;
+ private Set<String> fieldsToReturn = newHashSet();
+ private boolean scroll = false;
+ private String userLogin;
+ private Set<String> userGroups = newHashSet();
+
+ public QueryContext() {
+ this.userLogin = UserSession.get().login();
+ this.userGroups = UserSession.get().userGroups();
+ }
+
+ /**
+ * Whether or not the search returns facets for the domain. Defaults to {@link #DEFAULT_OFFSET}
+ */
+ public boolean isFacet() {
+ return facet;
+ }
+
+ /**
+ * Sets whether or not the search returns facets for the domain.
+ */
+ public QueryContext setFacet(boolean facet) {
+ this.facet = facet;
+ return this;
+ }
+
+ /**
+ * Whether or not the search result will be scrollable using an iterator
+ */
+ public boolean isScroll() {
+ return scroll;
+ }
+
+ /**
+ * Sets whether or not the search result will be scrollable using an iterator
+ */
+ public QueryContext setScroll(boolean scroll) {
+ this.scroll = scroll;
+ return this;
+ }
+
+ /**
+ * Offset of the first result to return. Defaults to {@link #DEFAULT_OFFSET}
+ */
+ public int getOffset() {
+ return offset;
+ }
+
+ /**
+ * Sets the offset of the first result to return (zero-based).
+ */
+ public QueryContext setOffset(int offset) {
+ Preconditions.checkArgument(offset >= 0, "Offset must be positive");
+ this.offset = offset;
+ return this;
+ }
+
+ /**
+ * Set offset and limit according to page approach
+ */
+ public QueryContext setPage(int page, int pageSize) {
+ Preconditions.checkArgument(page >= 1, "Page must be greater or equal to 1 (got " + page + ")");
+ Preconditions.checkArgument(pageSize >= 0, "Page size must be greater or equal to 0 (got " + pageSize + ")");
+ setLimit(pageSize);
+ setOffset((page * getLimit()) - getLimit());
+ return this;
+ }
+
+ /**
+ * Limit on the number of results to return. Defaults to {@link #DEFAULT_LIMIT}.
+ */
+ public int getLimit() {
+ return limit;
+ }
+
+ /**
+ * Sets the limit on the number of results to return.
+ */
+ public QueryContext setLimit(int limit) {
+ this.limit = Math.min(limit, MAX_LIMIT);
+ return this;
+ }
+
+ public QueryContext setMaxLimit() {
+ this.limit = MAX_LIMIT;
+ return this;
+ }
+
+ public Set<String> getFieldsToReturn() {
+ return fieldsToReturn;
+ }
+
+ public QueryContext setFieldsToReturn(@Nullable Collection<String> c) {
+ fieldsToReturn.clear();
+ if (c != null) {
+ this.fieldsToReturn = newHashSet(c);
+ }
+ return this;
+ }
+
+ public QueryContext addFieldsToReturn(@Nullable Collection<String> c) {
+ if (c != null) {
+ fieldsToReturn.addAll(c);
+ }
+ return this;
+ }
+
+ public QueryContext addFieldsToReturn(String... c) {
+ return addFieldsToReturn(Arrays.asList(c));
+ }
+
+ public String getUserLogin() {
+ return userLogin;
+ }
+
+ public Set<String> getUserGroups() {
+ return userGroups;
+ }
+
+}
+++ /dev/null
-/*
- * SonarQube, open source software quality management tool.
- * Copyright (C) 2008-2014 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.search;
-
-import com.google.common.base.Preconditions;
-import com.google.common.collect.Sets;
-
-import javax.annotation.Nullable;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Set;
-
-/**
- * Various Elasticsearch request options: paging, sorting, fields and facets
- *
- * @since 4.4
- */
-public class QueryOptions {
-
- public static final int DEFAULT_OFFSET = 0;
- public static final int DEFAULT_LIMIT = 10;
- public static final int MAX_LIMIT = 500;
- public static final boolean DEFAULT_FACET = false;
-
- private int offset = DEFAULT_OFFSET;
- private int limit = DEFAULT_LIMIT;
- private boolean facet = DEFAULT_FACET;
- private Set<String> fieldsToReturn = Sets.newHashSet();
- private boolean scroll = false;
-
- /**
- * Whether or not the search returns facets for the domain. Defaults to {@link #DEFAULT_OFFSET}
- */
- public boolean isFacet() {
- return facet;
- }
-
- /**
- * Sets whether or not the search returns facets for the domain.
- */
- public QueryOptions setFacet(boolean facet) {
- this.facet = facet;
- return this;
- }
-
- /**
- * Whether or not the search result will be scrollable using an iterator
- */
- public boolean isScroll() {
- return scroll;
- }
-
- /**
- * Sets whether or not the search result will be scrollable using an iterator
- */
- public QueryOptions setScroll(boolean scroll) {
- this.scroll = scroll;
- return this;
- }
-
- /**
- * Offset of the first result to return. Defaults to {@link #DEFAULT_OFFSET}
- */
- public int getOffset() {
- return offset;
- }
-
- /**
- * Sets the offset of the first result to return (zero-based).
- */
- public QueryOptions setOffset(int offset) {
- Preconditions.checkArgument(offset >= 0, "Offset must be positive");
- this.offset = offset;
- return this;
- }
-
- /**
- * Set offset and limit according to page approach
- */
- public QueryOptions setPage(int page, int pageSize) {
- Preconditions.checkArgument(page >= 1, "Page must be greater or equal to 1 (got " + page + ")");
- Preconditions.checkArgument(pageSize >= 0, "Page size must be greater or equal to 0 (got " + pageSize + ")");
- setLimit(pageSize);
- setOffset((page * getLimit()) - getLimit());
- return this;
- }
-
- /**
- * Limit on the number of results to return. Defaults to {@link #DEFAULT_LIMIT}.
- */
- public int getLimit() {
- return limit;
- }
-
- /**
- * Sets the limit on the number of results to return.
- */
- public QueryOptions setLimit(int limit) {
- this.limit = Math.min(limit, MAX_LIMIT);
- return this;
- }
-
- public QueryOptions setMaxLimit() {
- this.limit = MAX_LIMIT;
- return this;
- }
-
- public Set<String> getFieldsToReturn() {
- return fieldsToReturn;
- }
-
- public QueryOptions setFieldsToReturn(@Nullable Collection<String> c) {
- fieldsToReturn.clear();
- if (c != null) {
- this.fieldsToReturn = Sets.newHashSet(c);
- }
- return this;
- }
-
- public QueryOptions addFieldsToReturn(@Nullable Collection<String> c) {
- if (c != null) {
- fieldsToReturn.addAll(c);
- }
- return this;
- }
-
- public QueryOptions addFieldsToReturn(String... c) {
- return addFieldsToReturn(Arrays.asList(c));
- }
-}
import org.sonar.api.utils.text.JsonWriter;
import org.sonar.server.search.BaseDoc;
import org.sonar.server.search.IndexUtils;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import javax.annotation.Nullable;
return mappers.keySet();
}
- public QueryOptions newQueryOptions(SearchOptions options) {
- QueryOptions result = new QueryOptions();
+ public QueryContext newQueryOptions(SearchOptions options) {
+ QueryContext result = new QueryContext();
result.setPage(options.page(), options.pageSize());
List<String> optionFields = options.fields();
if (optionFields != null) {
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.WebService;
import org.sonar.api.utils.text.JsonWriter;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.search.Result;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
+
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
.createParam(PARAM_PAGE_SIZE)
.setDescription("Page size. Must be greater than 0.")
.setExampleValue("20")
- .setDefaultValue(String.valueOf(QueryOptions.DEFAULT_LIMIT));
+ .setDefaultValue(String.valueOf(QueryContext.DEFAULT_LIMIT));
}
}
import javax.annotation.Nullable;
+import java.util.List;
+
public class RubyUserSession {
/**
* Invoked by Ruby code - see application_controller.rb
*/
- public static void setSession(@Nullable Integer userId, @Nullable String login, @Nullable String name, @Nullable String localeRubyKey) {
- UserSession session = new UserSession().setLogin(login).setName(name).setUserId(userId).setLocale(JRubyI18n.toLocale(localeRubyKey));
+ public static void setSession(@Nullable Integer userId, @Nullable String login, @Nullable String name, @Nullable List<String> userGroups, @Nullable String localeRubyKey) {
+ UserSession session = new UserSession()
+ .setLogin(login)
+ .setName(name)
+ .setUserId(userId)
+ .setUserGroups(userGroups != null ? userGroups.toArray(new String[userGroups.size()]) : null)
+ .setLocale(JRubyI18n.toLocale(localeRubyKey));
UserSession.set(session);
}
import com.google.common.collect.HashMultimap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import org.sonar.api.security.DefaultGroups;
import org.sonar.core.permission.GlobalPermissions;
import org.sonar.core.resource.ResourceDao;
import org.sonar.core.resource.ResourceDto;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
+import java.util.*;
import static com.google.common.collect.Lists.newArrayList;
import static com.google.common.collect.Maps.newHashMap;
+import static com.google.common.collect.Sets.newHashSet;
/**
* Part of the current HTTP session
private Integer userId;
private String login;
private String name;
+ private Set<String> userGroups;
private Locale locale = Locale.ENGLISH;
List<String> globalPermissions = null;
List<String> projectPermissions = newArrayList();
UserSession() {
+ // Do not forget that when forceAuthentication is set to true, the Anyone group should not be set (but this will be check when authentication will be done in Java)
+ userGroups = newHashSet(DefaultGroups.ANYONE);
}
@CheckForNull
return this;
}
+ public Set<String> userGroups() {
+ return userGroups;
+ }
+
+ UserSession setUserGroups(@Nullable String... userGroups) {
+ if (userGroups != null) {
+ this.userGroups.addAll(Arrays.asList(userGroups));
+ }
+ return this;
+ }
+
public boolean isLoggedIn() {
return login != null;
}
import org.sonar.core.user.GroupMapper;
import org.sonar.server.db.BaseDao;
+import java.util.List;
+
/**
* @since 3.2
*/
return item;
}
+ public List<GroupDto> findByUserLogin(DbSession session, String login){
+ return mapper(session).selectByUserLogin(login);
+ }
+
}
import org.sonar.server.activity.index.ActivityQuery;
import org.sonar.server.db.DbClient;
import org.sonar.server.platform.Platform;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.search.Result;
import org.sonar.server.tester.ServerTester;
service.write(dbSession, Activity.Type.QPROFILE, "now");
dbSession.commit();
- Activity activity = service.search(new ActivityQuery(), new QueryOptions()).getHits().get(0);
+ Activity activity = service.search(new ActivityQuery(), new QueryContext()).getHits().get(0);
assertThat(System.currentTimeMillis() - activity.time().getTime()).isLessThan(1000L);
}
// 2. assert scrollable
int count = 0;
- SearchResponse result = index.search(new ActivityQuery(), new QueryOptions().setScroll(true));
+ SearchResponse result = index.search(new ActivityQuery(), new QueryContext().setScroll(true));
Iterator<Activity> logs = new Result<Activity>(index, result).scroll();
while (logs.hasNext()) {
logs.next();
// 3 assert synchronize above IndexQueue threshold
tester.clearIndexes();
tester.get(Platform.class).executeStartupTasks();
- result = index.search(new ActivityQuery(), new QueryOptions().setScroll(true));
+ result = index.search(new ActivityQuery(), new QueryContext().setScroll(true));
logs = new Result<Activity>(index, result).scroll();
count = 0;
while (logs.hasNext()) {
// 2. assert scrollable
int count = 0;
- SearchResponse result = index.search(new ActivityQuery(), new QueryOptions().setScroll(true));
+ SearchResponse result = index.search(new ActivityQuery(), new QueryContext().setScroll(true));
Iterator<Activity> logs = new Result<Activity>(index, result).scroll();
while (logs.hasNext()) {
logs.next();
// 3 assert synchronize above IndexQueue threshold
tester.clearIndexes();
tester.get(Platform.class).executeStartupTasks();
- result = index.search(new ActivityQuery(), new QueryOptions().setScroll(true));
+ result = index.search(new ActivityQuery(), new QueryContext().setScroll(true));
logs = new Result<Activity>(index, result).scroll();
count = 0;
while (logs.hasNext()) {
import org.sonar.server.activity.index.ActivityIndex;
import org.sonar.server.activity.index.ActivityQuery;
import org.sonar.server.db.DbClient;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.search.Result;
import org.sonar.server.tester.ServerTester;
dbSession.commit();
assertThat(index.findAll().getTotal()).isEqualTo(1);
- SearchResponse result = index.search(service.newActivityQuery(), new QueryOptions());
+ SearchResponse result = index.search(service.newActivityQuery(), new QueryContext());
assertThat(result.getHits().getTotalHits()).isEqualTo(1L);
Result<Activity> activityResult = new Result<Activity>(index, result);
assertThat(activityResult.getHits().get(0).message()).isEqualTo(testValue);
dbSession.commit();
assertThat(index.findAll().getTotal()).isEqualTo(1);
- SearchResponse result = index.search(service.newActivityQuery(), new QueryOptions());
+ SearchResponse result = index.search(service.newActivityQuery(), new QueryContext());
assertThat(result.getHits().getTotalHits()).isEqualTo(1L);
Result<Activity> activityResult = new Result<Activity>(index, result);
assertThat(activityResult.getHits().get(0).details().get(test_key)).isEqualTo(test_value);
dbSession.commit();
assertThat(service.search(new ActivityQuery(),
- new QueryOptions()).getHits()).hasSize(4);
+ new QueryContext()).getHits()).hasSize(4);
assertThat(service.search(new ActivityQuery()
.setTypes(ImmutableSet.of(Activity.Type.SERVER)),
- new QueryOptions()).getHits()).hasSize(2);
+ new QueryContext()).getHits()).hasSize(2);
assertThat(service.search(new ActivityQuery()
.setTypes(ImmutableSet.of(Activity.Type.QPROFILE)),
- new QueryOptions()).getHits()).hasSize(1);
+ new QueryContext()).getHits()).hasSize(1);
}
@Test
DateTime t2 = new DateTime().plusHours(1);
assertThat(service.search(new ActivityQuery(),
- new QueryOptions()).getHits()).hasSize(3);
+ new QueryContext()).getHits()).hasSize(3);
assertThat(service.search(new ActivityQuery()
.setSince(t0.minusSeconds(5).toDate()),
- new QueryOptions()).getHits()).hasSize(3);
+ new QueryContext()).getHits()).hasSize(3);
assertThat(service.search(new ActivityQuery()
.setSince(t1.minusSeconds(5).toDate()),
- new QueryOptions()).getHits()).hasSize(1);
+ new QueryContext()).getHits()).hasSize(1);
assertThat(service.search(new ActivityQuery()
.setSince(t2.minusSeconds(5).toDate()),
- new QueryOptions()).getHits()).hasSize(0);
+ new QueryContext()).getHits()).hasSize(0);
assertThat(service.search(new ActivityQuery()
.setTo(t1.minusSeconds(5).toDate()),
- new QueryOptions()).getHits()).hasSize(2);
+ new QueryContext()).getHits()).hasSize(2);
assertThat(service.search(new ActivityQuery()
.setSince(t1.minusSeconds(5).toDate())
.setTo(t2.plusSeconds(5).toDate()),
- new QueryOptions()).getHits()).hasSize(1);
+ new QueryContext()).getHits()).hasSize(1);
}
private ActivityDto getActivityDto() {
@Test
public void iterate_all() throws InterruptedException {
- int max = QueryOptions.DEFAULT_LIMIT + 3;
+ int max = QueryContext.DEFAULT_LIMIT + 3;
final String testValue = "hello world";
for (int i = 0; i < max; i++) {
service.write(dbSession, Activity.Type.QPROFILE, testValue + "_" + i);
// 0. assert Base case
assertThat(dao.findAll(dbSession)).hasSize(max);
- SearchResponse result = index.search(service.newActivityQuery(), new QueryOptions().setScroll(true));
+ SearchResponse result = index.search(service.newActivityQuery(), new QueryContext().setScroll(true));
assertThat(result.getHits().getTotalHits()).isEqualTo(max);
Result<Activity> activityResult = new Result<Activity>(index, result);
import org.sonar.server.qualityprofile.QProfileActivity;
import org.sonar.server.qualityprofile.QProfileActivityQuery;
import org.sonar.server.qualityprofile.QProfileService;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.search.Result;
import java.util.Date;
ArgumentCaptor<QProfileActivityQuery> activityArgumentCaptor;
@Captor
- ArgumentCaptor<QueryOptions> queryOptionsArgumentCaptor;
+ ArgumentCaptor<QueryContext> queryOptionsArgumentCaptor;
RubyQProfileActivityService rubyQProfileActivityService;
Result<QProfileActivity> result = mock(Result.class);
when(result.getHits()).thenReturn(Lists.<QProfileActivity>newArrayList());
when(result.getTotal()).thenReturn(10L);
- when(service.searchActivities(any(QProfileActivityQuery.class), any(QueryOptions.class))).thenReturn(result);
+ when(service.searchActivities(any(QProfileActivityQuery.class), any(QueryContext.class))).thenReturn(result);
rubyQProfileActivityService.search(ImmutableMap.<String, Object>of("profileKeys", "PROFILE_KEY", "since", since, "to", to));
Result<QProfileActivity> result = mock(Result.class);
when(result.getHits()).thenReturn(Lists.<QProfileActivity>newArrayList());
when(result.getTotal()).thenReturn(10L);
- when(service.searchActivities(any(QProfileActivityQuery.class), any(QueryOptions.class))).thenReturn(result);
+ when(service.searchActivities(any(QProfileActivityQuery.class), any(QueryContext.class))).thenReturn(result);
rubyQProfileActivityService.search(ImmutableMap.<String, Object>of());
import org.sonar.server.rule.Rule;
import org.sonar.server.rule.RuleService;
import org.sonar.server.rule.index.RuleQuery;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.search.Result;
import org.sonar.server.ui.ViewProxy;
import org.sonar.server.ui.Views;
when(rule.key()).thenReturn(RuleKey.of("manual", "API"));
when(rule.name()).thenReturn("API");
when(result.getHits()).thenReturn(newArrayList(rule));
- when(ruleService.search(any(RuleQuery.class), any(QueryOptions.class))).thenReturn(result);
+ when(ruleService.search(any(RuleQuery.class), any(QueryContext.class))).thenReturn(result);
WsTester.TestRequest request = tester.newGetRequest("api/components", "app").setParam("key", COMPONENT_KEY);
request.execute().assertJson(getClass(), "app_with_manual_rules.json");
import org.junit.ClassRule;
import org.junit.Test;
import org.sonar.api.issue.IssueQuery;
+import org.sonar.api.security.DefaultGroups;
import org.sonar.api.utils.DateUtils;
+import org.sonar.api.web.UserRole;
import org.sonar.core.component.ComponentDto;
import org.sonar.core.issue.db.IssueDto;
+import org.sonar.core.permission.PermissionFacade;
import org.sonar.core.persistence.DbSession;
import org.sonar.core.rule.RuleDto;
import org.sonar.server.component.persistence.ComponentDao;
import org.sonar.server.issue.index.IssueResult;
import org.sonar.server.rule.RuleTesting;
import org.sonar.server.rule.db.RuleDao;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.tester.ServerTester;
+import java.util.Date;
import java.util.UUID;
import static org.fest.assertions.Assertions.assertThat;
.setKey("MyComponent")
.setId(2L);
tester.get(ComponentDao.class).insert(session, resource);
+
+ // project can be seen by anyone
+ tester.get(PermissionFacade.class).insertGroupPermission(project.getId(), DefaultGroups.ANYONE, UserRole.USER, session);
+ db.issueAuthorizationDao().synchronizeAfter(session, new Date(0));
+
session.commit();
}
tester.get(IssueDao.class).insert(session, issue1, issue2);
session.commit();
- IssueResult result = service.search(IssueQuery.builder().build(), new QueryOptions());
+ IssueResult result = service.search(IssueQuery.builder().build(), new QueryContext());
assertThat(result.getHits()).hasSize(2);
assertThat(result.getFacets()).isEmpty();
- result = service.search(IssueQuery.builder().build(), new QueryOptions().setFacet(true));
+ result = service.search(IssueQuery.builder().build(), new QueryContext().setFacet(true));
assertThat(result.getFacets().keySet()).hasSize(4);
assertThat(result.getFacetKeys("actionPlan")).hasSize(2);
}
tester.get(IssueDao.class).insert(session, issue1, issue2);
session.commit();
- IssueResult result = service.search(IssueQuery.builder().build(), new QueryOptions());
+ IssueResult result = service.search(IssueQuery.builder().build(), new QueryContext());
assertThat(result.projects()).hasSize(1);
assertThat(result.components()).hasSize(1);
}
assertThat(dto.getProject()).isEqualTo("org.struts:struts");
assertThat(dto.getKey()).isEqualTo("org.struts:struts");
assertThat(dto.getPermission()).isEqualTo("user");
- assertThat(dto.getGroups()).containsExactly("anyone", "devs");
+ assertThat(dto.getGroups()).containsExactly("Anyone", "devs");
assertThat(dto.getUsers()).containsExactly("user1");
}
assertThat(indexClient.get(IssueIndex.class).countAll()).isEqualTo(1);
}
- @Test
- public void synchronize_issue_authorization_index() throws Exception {
-
- }
-
@Test
public void issue_authorization_on_group() throws Exception {
SearchClient searchClient = tester.get(SearchClient.class);
}
private SearchResponse searchIssueWithAuthorization(SearchClient searchClient, String user, String... groups) {
- BoolFilterBuilder fb = FilterBuilders.boolFilter();
+ BoolFilterBuilder permissionFilter = FilterBuilders.boolFilter();
OrFilterBuilder or = FilterBuilders.orFilter(FilterBuilders.termFilter("users", user));
for (String group : groups) {
or.add(FilterBuilders.termFilter("groups", group));
}
- fb.must(FilterBuilders.termFilter("permission", "read"), or).cache(true);
- // fb.must(FilterBuilders.termFilter("permission", "read"), or);
+ permissionFilter.must(FilterBuilders.termFilter("permission", "read"), or).cache(true);
SearchRequestBuilder request = searchClient.prepareSearch(IndexDefinition.ISSUES.getIndexName()).setTypes(IndexDefinition.ISSUES.getIndexType())
.setQuery(
QueryBuilders.matchAllQuery(),
FilterBuilders.hasParentFilter(IndexDefinition.ISSUES_AUTHORIZATION.getIndexType(),
QueryBuilders.filteredQuery(
- QueryBuilders.matchAllQuery(), fb)
+ QueryBuilders.matchAllQuery(), permissionFilter)
)
)
)
import org.junit.ClassRule;
import org.junit.Test;
import org.sonar.api.issue.IssueQuery;
+import org.sonar.api.security.DefaultGroups;
import org.sonar.api.utils.DateUtils;
+import org.sonar.api.web.UserRole;
import org.sonar.core.component.ComponentDto;
import org.sonar.core.issue.db.IssueDto;
+import org.sonar.core.permission.PermissionFacade;
import org.sonar.core.persistence.DbSession;
import org.sonar.core.rule.RuleDto;
+import org.sonar.core.user.GroupDto;
+import org.sonar.core.user.UserDto;
import org.sonar.server.component.persistence.ComponentDao;
import org.sonar.server.db.DbClient;
import org.sonar.server.rule.RuleTesting;
import org.sonar.server.rule.db.RuleDao;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.tester.ServerTester;
+import org.sonar.server.user.MockUserSession;
+import java.util.Date;
import java.util.UUID;
import static org.fest.assertions.Assertions.assertThat;
.setKey("MyComponent")
.setId(2L);
tester.get(ComponentDao.class).insert(session, resource);
+
+ // project can be seen by anyone
+ tester.get(PermissionFacade.class).insertGroupPermission(project.getId(), DefaultGroups.ANYONE, UserRole.USER, session);
+ db.issueAuthorizationDao().synchronizeAfter(session, new Date(0));
+
+ MockUserSession.set();
+
+ session.commit();
+ session.clearCache();
}
@After
@Test
public void filter_by_actionPlan() throws Exception {
-
String plan1 = "plan1";
String plan2 = "plan2";
- IssueDto issue1 = getIssue()
+ IssueDto issue1 = createIssue()
.setActionPlanKey(plan1);
- IssueDto issue2 = getIssue()
+ IssueDto issue2 = createIssue()
.setActionPlanKey(plan2);
db.issueDao().insert(session, issue1, issue2);
session.commit();
IssueQuery.Builder query = IssueQuery.builder();
query.actionPlans(ImmutableList.of(plan1));
- SearchResponse result = index.search(query.build(), new QueryOptions());
+ SearchResponse result = index.search(query.build(), new QueryContext());
+
assertThat(result.getHits().getTotalHits()).isEqualTo(1L);
query = IssueQuery.builder();
query.actionPlans(ImmutableList.of(plan2));
- result = index.search(query.build(), new QueryOptions());
+ result = index.search(query.build(), new QueryContext());
assertThat(result.getHits().getTotalHits()).isEqualTo(1L);
query = IssueQuery.builder();
query.actionPlans(ImmutableList.of(plan2, plan1));
- result = index.search(query.build(), new QueryOptions());
+ result = index.search(query.build(), new QueryContext());
assertThat(result.getHits().getTotalHits()).isEqualTo(2L);
}
@Test
public void is_assigned_filter() throws Exception {
-
String assignee = "steph";
- IssueDto issue1 = getIssue()
+ IssueDto issue1 = createIssue()
.setAssignee(assignee);
- IssueDto issue2 = getIssue();
+ IssueDto issue2 = createIssue();
db.issueDao().insert(session, issue1, issue2);
session.commit();
IssueQuery.Builder query = IssueQuery.builder();
- SearchResponse result = index.search(query.build(), new QueryOptions());
+ SearchResponse result = index.search(query.build(), new QueryContext());
assertThat(result.getHits().getTotalHits()).isEqualTo(2L);
query = IssueQuery.builder();
query.assigned(true);
- result = index.search(query.build(), new QueryOptions());
+ result = index.search(query.build(), new QueryContext());
assertThat(result.getHits().getTotalHits()).isEqualTo(1L);
}
@Test
public void filter_assignee() throws Exception {
-
String assignee1 = "steph";
String assignee2 = "simon";
- IssueDto issue1 = getIssue()
+ IssueDto issue1 = createIssue()
.setAssignee(assignee1);
- IssueDto issue2 = getIssue()
+ IssueDto issue2 = createIssue()
.setAssignee(assignee2);
- IssueDto issue3 = getIssue();
+ IssueDto issue3 = createIssue();
db.issueDao().insert(session, issue1, issue2, issue3);
session.commit();
IssueQuery.Builder query = IssueQuery.builder();
- SearchResponse result = index.search(query.build(), new QueryOptions());
+ SearchResponse result = index.search(query.build(), new QueryContext());
assertThat(result.getHits().getTotalHits()).isEqualTo(3L);
query = IssueQuery.builder();
query.assignees(ImmutableList.of(assignee1));
- result = index.search(query.build(), new QueryOptions());
+ result = index.search(query.build(), new QueryContext());
assertThat(result.getHits().getTotalHits()).isEqualTo(1L);
query = IssueQuery.builder();
query.assignees(ImmutableList.of(assignee1, assignee2));
- result = index.search(query.build(), new QueryOptions());
+ result = index.search(query.build(), new QueryContext());
assertThat(result.getHits().getTotalHits()).isEqualTo(2L);
}
- private IssueDto getIssue() {
+ @Test
+ public void authorized_issues_on_groups() throws Exception {
+ ComponentDto project1 = new ComponentDto()
+ .setId(10L)
+ .setKey("project1");
+ ComponentDto project2 = new ComponentDto()
+ .setId(11L)
+ .setKey("project2");
+ tester.get(ComponentDao.class).insert(session, project1, project2);
+
+ IssueDto issue1 = createIssue().setRootComponent(project1);
+ IssueDto issue2 = createIssue().setRootComponent(project2);
+ db.issueDao().insert(session, issue1, issue2);
+
+ // project1 can be seen by sonar-users
+ GroupDto groupDto = new GroupDto().setName("sonar-users");
+ db.groupDao().insert(session, groupDto);
+ tester.get(PermissionFacade.class).insertGroupPermission(project1.getId(), groupDto.getName(), UserRole.USER, session);
+
+ // project2 can be seen by sonar-admins
+ groupDto = new GroupDto().setName("sonar-admins");
+ db.groupDao().insert(session, groupDto);
+ tester.get(PermissionFacade.class).insertGroupPermission(project2.getId(), groupDto.getName(), UserRole.USER, session);
+
+
+ db.issueAuthorizationDao().synchronizeAfter(session, new Date(0));
+
+ session.commit();
+ session.clearCache();
+
+ IssueQuery.Builder query = IssueQuery.builder();
+
+ MockUserSession.set().setUserGroups("sonar-users");
+ assertThat(index.search(query.build(), new QueryContext()).getHits().getTotalHits()).isEqualTo(1L);
+
+ MockUserSession.set().setUserGroups("sonar-admins");
+ assertThat(index.search(query.build(), new QueryContext()).getHits().getTotalHits()).isEqualTo(1L);
+
+ MockUserSession.set().setUserGroups("sonar-users", "sonar-admins");
+ assertThat(index.search(query.build(), new QueryContext()).getHits().getTotalHits()).isEqualTo(2L);
+
+ MockUserSession.set().setUserGroups("another group");
+ assertThat(index.search(query.build(), new QueryContext()).getHits().getTotalHits()).isEqualTo(0);
+ }
+
+ @Test
+ public void authorized_issues_on_user() throws Exception {
+ ComponentDto project1 = new ComponentDto()
+ .setId(10L)
+ .setKey("project1");
+ ComponentDto project2 = new ComponentDto()
+ .setId(11L)
+ .setKey("project2");
+ tester.get(ComponentDao.class).insert(session, project1, project2);
+
+ IssueDto issue1 = createIssue().setRootComponent(project1);
+ IssueDto issue2 = createIssue().setRootComponent(project2);
+ db.issueDao().insert(session, issue1, issue2);
+
+ // project1 can be seen by john
+ UserDto john = new UserDto().setLogin("john").setName("john").setActive(true);
+ db.userDao().insert(session, john);
+ tester.get(PermissionFacade.class).insertUserPermission(project1.getId(), john.getId(), UserRole.USER, session);
+
+ // project2 can be seen by max
+ UserDto max = new UserDto().setLogin("max").setName("max").setActive(true);
+ db.userDao().insert(session, max);
+ tester.get(PermissionFacade.class).insertUserPermission(project2.getId(), max.getId(), UserRole.USER, session);
+
+ db.issueAuthorizationDao().synchronizeAfter(session, new Date(0));
+
+ session.commit();
+ session.clearCache();
+
+ IssueQuery.Builder query = IssueQuery.builder();
+
+ MockUserSession.set().setLogin("john");
+ assertThat(index.search(query.build(), new QueryContext()).getHits().getTotalHits()).isEqualTo(1L);
+
+ MockUserSession.set().setLogin("max");
+ assertThat(index.search(query.build(), new QueryContext()).getHits().getTotalHits()).isEqualTo(1L);
+
+ MockUserSession.set().setLogin("another guy");
+ assertThat(index.search(query.build(), new QueryContext()).getHits().getTotalHits()).isEqualTo(0L);
+ }
+
+ @Test
+ public void authorized_issues_on_user_with_group() throws Exception {
+ ComponentDto project1 = new ComponentDto()
+ .setId(10L)
+ .setKey("project1");
+ ComponentDto project2 = new ComponentDto()
+ .setId(11L)
+ .setKey("project2");
+ tester.get(ComponentDao.class).insert(session, project1, project2);
+
+ IssueDto issue1 = createIssue().setRootComponent(project1);
+ IssueDto issue2 = createIssue().setRootComponent(project2);
+ db.issueDao().insert(session, issue1, issue2);
+
+ // project1 can be seen by john
+ UserDto john = new UserDto().setLogin("john").setName("john").setActive(true);
+ db.userDao().insert(session, john);
+ tester.get(PermissionFacade.class).insertUserPermission(project1.getId(), john.getId(), UserRole.USER, session);
+
+ // project1 can be seen by sonar-users
+ GroupDto groupDto = new GroupDto().setName("sonar-users");
+ db.groupDao().insert(session, groupDto);
+ tester.get(PermissionFacade.class).insertGroupPermission(project1.getId(), "sonar-users", UserRole.USER, session);
+
+ db.issueAuthorizationDao().synchronizeAfter(session, new Date(0));
+
+ session.commit();
+ session.clearCache();
+
+ IssueQuery.Builder query = IssueQuery.builder();
+
+ MockUserSession.set().setLogin("john").setUserGroups("sonar-users");
+ assertThat(index.search(query.build(), new QueryContext()).getHits().getTotalHits()).isEqualTo(1L);
+ }
+
+ private IssueDto createIssue() {
return new IssueDto()
.setIssueCreationDate(DateUtils.parseDate("2014-09-04"))
.setIssueUpdateDate(DateUtils.parseDate("2014-12-04"))
import org.junit.Before;
import org.junit.ClassRule;
import org.junit.Test;
+import org.sonar.api.security.DefaultGroups;
import org.sonar.api.server.ws.WebService;
import org.sonar.api.utils.DateUtils;
+import org.sonar.api.web.UserRole;
import org.sonar.core.component.ComponentDto;
import org.sonar.core.issue.db.IssueDto;
import org.sonar.core.permission.GlobalPermissions;
+import org.sonar.core.permission.PermissionFacade;
import org.sonar.core.persistence.DbSession;
import org.sonar.core.rule.RuleDto;
import org.sonar.server.component.persistence.ComponentDao;
import org.sonar.server.user.MockUserSession;
import org.sonar.server.ws.WsTester;
+import java.util.Date;
+
import static org.fest.assertions.Assertions.assertThat;
public class IssuesWsMediumTest {
.setProjectId(1L);
tester.get(ComponentDao.class).insert(session, project);
+ // project can be seen by anyone
+ tester.get(PermissionFacade.class).insertGroupPermission(project.getId(), DefaultGroups.ANYONE, UserRole.USER, session);
+ db.issueAuthorizationDao().synchronizeAfter(session, new Date(0));
+
ComponentDto resource = new ComponentDto()
.setProjectId(1L)
.setKey("MyComponent")
import org.sonar.server.qualityprofile.index.ActiveRuleNormalizer;
import org.sonar.server.rule.RuleTesting;
import org.sonar.server.search.FacetValue;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.search.Result;
import org.sonar.server.tester.ServerTester;
import org.sonar.server.user.MockUserSession;
);
dbSession.commit();
- Result<QProfileActivity> activities = service.searchActivities(new QProfileActivityQuery(), new QueryOptions());
+ Result<QProfileActivity> activities = service.searchActivities(new QProfileActivityQuery(), new QueryContext());
assertThat(activities.getHits()).hasSize(1);
QProfileActivity activity = activities.getHits().get(0);
);
dbSession.commit();
- Result<QProfileActivity> activities = service.searchActivities(new QProfileActivityQuery(), new QueryOptions());
+ Result<QProfileActivity> activities = service.searchActivities(new QProfileActivityQuery(), new QueryContext());
assertThat(activities.getHits()).hasSize(1);
QProfileActivity activity = activities.getHits().get(0);
);
dbSession.commit();
- Result<QProfileActivity> activities = service.searchActivities(new QProfileActivityQuery(), new QueryOptions());
+ Result<QProfileActivity> activities = service.searchActivities(new QProfileActivityQuery(), new QueryContext());
assertThat(activities.getHits()).hasSize(1);
QProfileActivity activity = activities.getHits().get(0);
);
dbSession.commit();
- Result<QProfileActivity> activities = service.searchActivities(new QProfileActivityQuery(), new QueryOptions());
+ Result<QProfileActivity> activities = service.searchActivities(new QProfileActivityQuery(), new QueryContext());
assertThat(activities.getHits()).hasSize(1);
QProfileActivity activity = activities.getHits().get(0);
dbSession.commit();
// 0. Base case verify 2 activities in index
- assertThat(service.searchActivities(new QProfileActivityQuery(), new QueryOptions()).getHits())
+ assertThat(service.searchActivities(new QProfileActivityQuery(), new QueryContext()).getHits())
.hasSize(2);
// 1. filter by QProfile
List<QProfileActivity> result = service.searchActivities(new QProfileActivityQuery()
- .setQprofileKeys(ImmutableSet.of(XOO_P1_KEY)), new QueryOptions()).getHits();
+ .setQprofileKeys(ImmutableSet.of(XOO_P1_KEY)), new QueryContext()).getHits();
assertThat(result).hasSize(1);
// 1. filter by QProfiles
assertThat(service.searchActivities(new QProfileActivityQuery()
.setQprofileKeys(ImmutableSet.of(XOO_P1_KEY, XOO_P2_KEY))
- , new QueryOptions()).getHits()).hasSize(2);
+ , new QueryContext()).getHits()).hasSize(2);
}
@Test
dbSession.commit();
// 0. Base case verify 2 activities in index
- assertThat(service.searchActivities(new QProfileActivityQuery(), new QueryOptions()).getHits())
+ assertThat(service.searchActivities(new QProfileActivityQuery(), new QueryContext()).getHits())
.hasSize(2);
// 1. filter by QProfile
List<QProfileActivity> result = service.searchActivities(new QProfileActivityQuery()
- .setQprofileKeys(ImmutableSet.of("java-default")), new QueryOptions()).getHits();
+ .setQprofileKeys(ImmutableSet.of("java-default")), new QueryContext()).getHits();
assertThat(result).hasSize(1);
// 1. filter by QProfiles
assertThat(service.searchActivities(new QProfileActivityQuery()
.setQprofileKeys(ImmutableSet.of("java-default", "java-toto"))
- , new QueryOptions()).getHits()).hasSize(2);
+ , new QueryContext()).getHits()).hasSize(2);
}
@Test
package org.sonar.server.qualityprofile;
import com.google.common.collect.ImmutableMap;
-import org.junit.*;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.ClassRule;
+import org.junit.Test;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.rule.RuleStatus;
import org.sonar.api.rule.Severity;
import org.sonar.server.rule.RuleTesting;
import org.sonar.server.rule.index.RuleIndex;
import org.sonar.server.rule.index.RuleQuery;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.tester.ServerTester;
import javax.annotation.Nullable;
@Test
public void bulk_activation() {
// Generate more rules than the search's max limit
- int bulkSize = QueryOptions.MAX_LIMIT + 10;
+ int bulkSize = QueryContext.MAX_LIMIT + 10;
for (int i = 0; i < bulkSize; i++) {
db.ruleDao().insert(dbSession, RuleTesting.newDto(RuleKey.of("bulk", "r_" + i)).setLanguage("xoo"));
}
// 0. No active rules so far (base case) and plenty rules available
verifyZeroActiveRules(XOO_P1_KEY);
assertThat(tester.get(RuleIndex.class)
- .search(new RuleQuery().setRepositories(Arrays.asList("bulk")), new QueryOptions()).getTotal())
+ .search(new RuleQuery().setRepositories(Arrays.asList("bulk")), new QueryContext()).getTotal())
.isEqualTo(bulkSize);
// 1. bulk activate all the rules
import org.sonar.server.rule.index.RuleIndex;
import org.sonar.server.rule.index.RuleQuery;
import org.sonar.server.rule.ws.SearchAction;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.search.ws.SearchOptions;
import org.sonar.server.tester.ServerTester;
import org.sonar.server.user.MockUserSession;
// 2. Assert ActiveRule with BLOCKER severity
assertThat(tester.get(RuleIndex.class).search(
new RuleQuery().setSeverities(ImmutableSet.of("BLOCKER")),
- new QueryOptions()).getHits()).hasSize(2);
+ new QueryContext()).getHits()).hasSize(2);
// 1. Activate Rule with query returning 2 hits
WsTester.TestRequest request = wsTester.newGetRequest(QProfilesWs.API_ENDPOINT, BulkRuleActivationActions.BULK_ACTIVATE_ACTION);
import org.sonar.server.qualityprofile.index.ActiveRuleIndex;
import org.sonar.server.rule.index.RuleIndex;
import org.sonar.server.rule.index.RuleQuery;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.search.Result;
import org.sonar.server.tester.ServerTester;
import org.sonar.server.user.MockUserSession;
assertThat(ruleParams).hasSize(2);
// verify es
- Result<Rule> searchResult = ruleIndex.search(new RuleQuery(), new QueryOptions());
+ Result<Rule> searchResult = ruleIndex.search(new RuleQuery(), new QueryContext());
assertThat(searchResult.getTotal()).isEqualTo(1);
assertThat(searchResult.getHits()).hasSize(1);
Rule rule = ruleIndex.getByKey(RuleKey.of("xoo", "x1"));
register(rules);
// verify that rules are indexed
- Result<Rule> searchResult = ruleIndex.search(new RuleQuery(), new QueryOptions());
- searchResult = ruleIndex.search(new RuleQuery().setKey("xoo:x1"), new QueryOptions());
+ Result<Rule> searchResult = ruleIndex.search(new RuleQuery(), new QueryContext());
+ searchResult = ruleIndex.search(new RuleQuery().setKey("xoo:x1"), new QueryContext());
assertThat(searchResult.getTotal()).isEqualTo(1);
assertThat(searchResult.getHits()).hasSize(1);
assertThat(searchResult.getHits().get(0).key()).isEqualTo(RuleKey.of("xoo", "x1"));
import org.sonar.api.rule.RuleStatus;
import org.sonar.server.paging.PagedResult;
import org.sonar.server.rule.index.RuleQuery;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.search.Result;
import org.sonar.server.user.UserSession;
RuleUpdater updater;
@Captor
- ArgumentCaptor<QueryOptions> optionsCaptor;
+ ArgumentCaptor<QueryContext> optionsCaptor;
@Captor
ArgumentCaptor<RuleQuery> ruleQueryCaptor;
@Test
public void search_rules() throws Exception {
- when(ruleService.search(any(RuleQuery.class), any(QueryOptions.class))).thenReturn(mock(Result.class));
+ when(ruleService.search(any(RuleQuery.class), any(QueryContext.class))).thenReturn(mock(Result.class));
HashMap<String, Object> params = newHashMap();
params.put("searchQuery", "Exception");
@Test
public void search_rules_without_page_size_param() throws Exception {
- when(ruleService.search(any(RuleQuery.class), any(QueryOptions.class))).thenReturn(mock(Result.class));
+ when(ruleService.search(any(RuleQuery.class), any(QueryContext.class))).thenReturn(mock(Result.class));
HashMap<String, Object> params = newHashMap();
params.put("p", "1");
Result serviceResult = mock(Result.class);
when(serviceResult.scroll()).thenReturn(rules.iterator());
- when(ruleService.search(any(RuleQuery.class), any(QueryOptions.class))).thenReturn(serviceResult);
+ when(ruleService.search(any(RuleQuery.class), any(QueryContext.class))).thenReturn(serviceResult);
HashMap<String, Object> params = newHashMap();
params.put("pageSize", "-1");
@Test
public void update_rule() throws Exception {
- when(ruleService.search(any(RuleQuery.class), any(QueryOptions.class))).thenReturn(mock(Result.class));
+ when(ruleService.search(any(RuleQuery.class), any(QueryContext.class))).thenReturn(mock(Result.class));
service.updateRule(ImmutableMap.<String, Object>of("ruleKey", "squid:S001"));
@Test
public void search_manual_rules() throws Exception {
- when(ruleService.search(any(RuleQuery.class), any(QueryOptions.class))).thenReturn(mock(Result.class));
+ when(ruleService.search(any(RuleQuery.class), any(QueryContext.class))).thenReturn(mock(Result.class));
service.searchManualRules();
- verify(ruleService).search(any(RuleQuery.class), any(QueryOptions.class));
+ verify(ruleService).search(any(RuleQuery.class), any(QueryContext.class));
}
@Test
import org.sonar.server.rule.index.RuleDoc;
import org.sonar.server.rule.index.RuleIndex;
import org.sonar.server.rule.index.RuleQuery;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.tester.ServerTester;
import java.util.Collection;
assertThat(index.getByKey(RuleTesting.XOO_X2)).isNotNull();
// 2. assert find does not get REMOVED
- List<Rule> rules = index.search(new RuleQuery(), new QueryOptions()).getHits();
+ List<Rule> rules = index.search(new RuleQuery(), new QueryContext()).getHits();
assertThat(rules).hasSize(1);
assertThat(rules.get(0).key()).isEqualTo(RuleTesting.XOO_X1);
}
import org.sonar.server.rule.RuleTesting;
import org.sonar.server.rule.db.RuleDao;
import org.sonar.server.search.FacetValue;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.search.Result;
import javax.annotation.Nullable;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Date;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Set;
+
+import java.util.*;
import static com.google.common.collect.Lists.newArrayList;
import static org.fest.assertions.Assertions.assertThat;
// should not have any facet!
RuleQuery query = new RuleQuery();
- Result result = index.search(query, new QueryOptions().setFacet(false));
+ Result result = index.search(query, new QueryContext().setFacet(false));
assertThat(result.getFacets()).isEmpty();
// Repositories Facet is preset
- result = index.search(query, new QueryOptions().setFacet(true));
+ result = index.search(query, new QueryContext().setFacet(true));
assertThat(result.getFacets()).isNotNull();
assertThat(result.getFacets()).hasSize(3);
dao.insert(dbSession, RuleTesting.newDto(RuleKey.of("javascript", "S001")));
dbSession.commit();
- QueryOptions options = new QueryOptions().setFieldsToReturn(null);
+ QueryContext options = new QueryContext().setFieldsToReturn(null);
Result<Rule> results = index.search(new RuleQuery(), options);
assertThat(results.getHits()).hasSize(1);
Rule hit = Iterables.getFirst(results.getHits(), null);
assertThat(hit.htmlDescription()).isNotNull();
assertThat(hit.name()).isNotNull();
- options = new QueryOptions().setFieldsToReturn(Collections.<String>emptyList());
+ options = new QueryContext().setFieldsToReturn(Collections.<String>emptyList());
results = index.search(new RuleQuery(), options);
assertThat(results.getHits()).hasSize(1);
hit = Iterables.getFirst(results.getHits(), null);
dao.insert(dbSession, RuleTesting.newDto(RuleKey.of("javascript", "S001")));
dbSession.commit();
- QueryOptions options = new QueryOptions();
+ QueryContext options = new QueryContext();
options.addFieldsToReturn(RuleNormalizer.RuleField.LANGUAGE.field(), RuleNormalizer.RuleField.STATUS.field());
Result<Rule> results = index.search(new RuleQuery(), options);
assertThat(results.getHits()).hasSize(1);
// substring
RuleQuery query = new RuleQuery().setQueryText("test");
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(1);
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
// substring
query = new RuleQuery().setQueryText("partial match");
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(1);
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
// case-insensitive
query = new RuleQuery().setQueryText("TESTING");
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(1);
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
// not found
query = new RuleQuery().setQueryText("not present");
- assertThat(index.search(query, new QueryOptions()).getHits()).isEmpty();
+ assertThat(index.search(query, new QueryContext()).getHits()).isEmpty();
}
@Test
// key
RuleQuery query = new RuleQuery().setQueryText("X001");
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
// partial key does not match
query = new RuleQuery().setQueryText("X00");
// TODO fix non-partial match for Key search
- assertThat(index.search(query, new QueryOptions()).getHits()).isEmpty();
+ assertThat(index.search(query, new QueryContext()).getHits()).isEmpty();
// repo:key -> nice-to-have !
query = new RuleQuery().setQueryText("javascript:X001");
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(1);
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
}
@Test
// key
RuleQuery query = new RuleQuery().setKey(RuleKey.of("javascript", "X001").toString());
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(1);
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
// partial key does not match
query = new RuleQuery().setKey("X001");
// TODO fix non-partial match for Key search
- assertThat(index.search(query, new QueryOptions()).getHits()).isEmpty();
+ assertThat(index.search(query, new QueryContext()).getHits()).isEmpty();
}
@Test
dao.insert(dbSession, RuleTesting.newDto(RuleKey.of("java", "S002")));
dbSession.commit();
- Result results = index.search(new RuleQuery(), new QueryOptions());
+ Result results = index.search(new RuleQuery(), new QueryContext());
assertThat(results.getTotal()).isEqualTo(2);
assertThat(results.getHits()).hasSize(2);
}
dbSession.commit();
- Result results = index.search(new RuleQuery(), new QueryOptions().setScroll(true));
+ Result results = index.search(new RuleQuery(), new QueryContext().setScroll(true));
assertThat(results.getTotal()).isEqualTo(max);
assertThat(results.getHits()).hasSize(0);
dbSession.commit();
// 0. assert base case
- assertThat(index.search(new RuleQuery(), new QueryOptions()).getTotal()).isEqualTo(2);
+ assertThat(index.search(new RuleQuery(), new QueryContext()).getTotal()).isEqualTo(2);
assertThat(db.debtCharacteristicDao().selectCharacteristics()).hasSize(2);
// 1. assert hasSubChar filter
- assertThat(index.search(new RuleQuery().setHasDebtCharacteristic(true), new QueryOptions()).getTotal())
+ assertThat(index.search(new RuleQuery().setHasDebtCharacteristic(true), new QueryContext()).getTotal())
.isEqualTo(2);
}
dbSession.commit();
RuleQuery query = new RuleQuery().setRepositories(Arrays.asList("checkstyle", "pmd"));
- Result<Rule> results = index.search(query, new QueryOptions());
+ Result<Rule> results = index.search(query, new QueryContext());
assertThat(results.getHits()).hasSize(1);
assertThat(Iterables.getFirst(results.getHits(), null).key().rule()).isEqualTo("S002");
// no results
query = new RuleQuery().setRepositories(Arrays.asList("checkstyle"));
- assertThat(index.search(query, new QueryOptions()).getHits()).isEmpty();
+ assertThat(index.search(query, new QueryContext()).getHits()).isEmpty();
// empty list => no filter
query = new RuleQuery().setRepositories(Collections.<String>emptyList());
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
}
@Test
dbSession.commit();
RuleQuery query = new RuleQuery().setLanguages(Arrays.asList("cobol", "js"));
- Result<Rule> results = index.search(query, new QueryOptions());
+ Result<Rule> results = index.search(query, new QueryContext());
assertThat(results.getHits()).hasSize(1);
assertThat(Iterables.getFirst(results.getHits(), null).key().rule()).isEqualTo("S002");
// no results
query = new RuleQuery().setLanguages(Arrays.asList("cpp"));
- assertThat(index.search(query, new QueryOptions()).getHits()).isEmpty();
+ assertThat(index.search(query, new QueryContext()).getHits()).isEmpty();
// empty list => no filter
query = new RuleQuery().setLanguages(Collections.<String>emptyList());
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
// null list => no filter
query = new RuleQuery().setLanguages(null);
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
}
@Test
Result<Rule> results;
// 0. we have 2 rules in index
- results = index.search(new RuleQuery(), new QueryOptions());
+ results = index.search(new RuleQuery(), new QueryContext());
assertThat(results.getHits()).hasSize(2);
// filter by non-subChar
query = new RuleQuery().setDebtCharacteristics(ImmutableSet.of("toto"));
- assertThat(index.search(query, new QueryOptions()).getHits()).isEmpty();
+ assertThat(index.search(query, new QueryContext()).getHits()).isEmpty();
// filter by subChar
query = new RuleQuery().setDebtCharacteristics(ImmutableSet.of(char11.getKey()));
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(1);
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
// filter by Char
query = new RuleQuery().setDebtCharacteristics(ImmutableSet.of(char1.getKey()));
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(1);
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
// filter by Char and SubChar
query = new RuleQuery().setDebtCharacteristics(ImmutableSet.of(char11.getKey(), char1.getKey()));
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(1);
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
// match by Char
query = new RuleQuery().setQueryText(char1.getKey());
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(1);
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
// match by SubChar
query = new RuleQuery().setQueryText(char11.getKey());
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(1);
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
// match by SubChar & Char
query = new RuleQuery().setQueryText(char11.getKey() + " " + char1.getKey());
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(1);
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
}
@Test
Result<Rule> results;
// 0. we have 4 rules in index
- results = index.search(new RuleQuery(), new QueryOptions());
+ results = index.search(new RuleQuery(), new QueryContext());
assertThat(results.getHits()).hasSize(4);
// filter by subChar
query = new RuleQuery().setDebtCharacteristics(ImmutableSet.of(char11.getKey()));
- assertThat(ruleKeys(index.search(query, new QueryOptions()).getHits())).containsOnly("S001", "S002", "S004");
+ assertThat(ruleKeys(index.search(query, new QueryContext()).getHits())).containsOnly("S001", "S002", "S004");
query = new RuleQuery().setDebtCharacteristics(ImmutableSet.of(char21.getKey()));
- assertThat(ruleKeys(index.search(query, new QueryOptions()).getHits())).containsOnly("S003");
+ assertThat(ruleKeys(index.search(query, new QueryContext()).getHits())).containsOnly("S003");
// filter by Char
query = new RuleQuery().setDebtCharacteristics(ImmutableSet.of(char1.getKey()));
- assertThat(ruleKeys(index.search(query, new QueryOptions()).getHits())).containsOnly("S001", "S002", "S004");
+ assertThat(ruleKeys(index.search(query, new QueryContext()).getHits())).containsOnly("S001", "S002", "S004");
query = new RuleQuery().setDebtCharacteristics(ImmutableSet.of(char2.getKey()));
- assertThat(ruleKeys(index.search(query, new QueryOptions()).getHits())).containsOnly("S003");
+ assertThat(ruleKeys(index.search(query, new QueryContext()).getHits())).containsOnly("S003");
// filter by Char and SubChar
query = new RuleQuery().setDebtCharacteristics(ImmutableSet.of(char11.getKey(), char1.getKey(), char2.getKey(), char21.getKey()));
- assertThat(ruleKeys(index.search(query, new QueryOptions()).getHits())).containsOnly("S001", "S002", "S003", "S004");
+ assertThat(ruleKeys(index.search(query, new QueryContext()).getHits())).containsOnly("S001", "S002", "S003", "S004");
}
@Test
dbSession.commit();
RuleQuery query = new RuleQuery().setSeverities(Arrays.asList(Severity.INFO, Severity.MINOR));
- Result<Rule> results = index.search(query, new QueryOptions());
+ Result<Rule> results = index.search(query, new QueryContext());
assertThat(results.getHits()).hasSize(1);
assertThat(Iterables.getFirst(results.getHits(), null).key().rule()).isEqualTo("S002");
// no results
query = new RuleQuery().setSeverities(Arrays.asList(Severity.MINOR));
- assertThat(index.search(query, new QueryOptions()).getHits()).isEmpty();
+ assertThat(index.search(query, new QueryContext()).getHits()).isEmpty();
// empty list => no filter
query = new RuleQuery().setSeverities(Collections.<String>emptyList());
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
// null list => no filter
query = new RuleQuery().setSeverities(null);
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
}
@Test
dbSession.commit();
RuleQuery query = new RuleQuery().setStatuses(Arrays.asList(RuleStatus.DEPRECATED, RuleStatus.READY));
- Result<Rule> results = index.search(query, new QueryOptions());
+ Result<Rule> results = index.search(query, new QueryContext());
assertThat(results.getHits()).hasSize(1);
assertThat(Iterables.getFirst(results.getHits(), null).key().rule()).isEqualTo("S002");
// no results
query = new RuleQuery().setStatuses(Arrays.asList(RuleStatus.DEPRECATED));
- assertThat(index.search(query, new QueryOptions()).getHits()).isEmpty();
+ assertThat(index.search(query, new QueryContext()).getHits()).isEmpty();
// empty list => no filter
query = new RuleQuery().setStatuses(Collections.<RuleStatus>emptyList());
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
// null list => no filter
query = new RuleQuery().setStatuses(null);
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
}
@Test
// ascending
RuleQuery query = new RuleQuery().setSortField(RuleNormalizer.RuleField.NAME);
- Result<Rule> results = index.search(query, new QueryOptions());
+ Result<Rule> results = index.search(query, new QueryContext());
assertThat(results.getHits()).hasSize(3);
assertThat(Iterables.getFirst(results.getHits(), null).key().rule()).isEqualTo("S002");
assertThat(Iterables.getLast(results.getHits(), null).key().rule()).isEqualTo("S003");
// descending
query = new RuleQuery().setSortField(RuleNormalizer.RuleField.NAME).setAscendingSort(false);
- results = index.search(query, new QueryOptions());
+ results = index.search(query, new QueryContext());
assertThat(results.getHits()).hasSize(3);
assertThat(Iterables.getFirst(results.getHits(), null).key().rule()).isEqualTo("S003");
assertThat(Iterables.getLast(results.getHits(), null).key().rule()).isEqualTo("S002");
// 1. get all active rules.
Result<Rule> result = index.search(new RuleQuery().setActivation(true),
- new QueryOptions());
+ new QueryContext());
assertThat(result.getHits()).hasSize(2);
// 2. get all inactive rules.
result = index.search(new RuleQuery().setActivation(false),
- new QueryOptions());
+ new QueryContext());
assertThat(result.getHits()).hasSize(1);
assertThat(result.getHits().get(0).name()).isEqualTo(rule3.getName());
// 3. get all rules not active on profile
index.search(new RuleQuery().setActivation(false).setQProfileKey(qualityProfileDto2.getKey()),
- new QueryOptions());
+ new QueryContext());
// TODO
assertThat(result.getHits()).hasSize(1);
// 4. get all active rules on profile
result = index.search(new RuleQuery().setActivation(true)
.setQProfileKey(qualityProfileDto2.getKey()),
- new QueryOptions());
+ new QueryContext());
assertThat(result.getHits()).hasSize(1);
assertThat(result.getHits().get(0).name()).isEqualTo(rule1.getName());
// 0. get all rules
Result<Rule> result = index.search(new RuleQuery(),
- new QueryOptions());
+ new QueryContext());
assertThat(result.getHits()).hasSize(4);
// 1. get all active rules
result = index.search(new RuleQuery().setActivation(true),
- new QueryOptions());
+ new QueryContext());
assertThat(result.getHits()).hasSize(3);
// 2. get all inactive rules.
result = index.search(new RuleQuery().setActivation(false),
- new QueryOptions());
+ new QueryContext());
assertThat(result.getHits()).hasSize(1);
assertThat(result.getHits().get(0).name()).isEqualTo(rule4.getName());
result = index.search(new RuleQuery().setActivation(true)
.setQProfileKey(qualityProfileDto1.getKey())
.setInheritance(ImmutableSet.of(ActiveRule.Inheritance.INHERITED.name())),
- new QueryOptions()
+ new QueryContext()
);
assertThat(result.getHits()).hasSize(0);
result = index.search(new RuleQuery().setActivation(true)
.setQProfileKey(qualityProfileDto2.getKey())
.setInheritance(ImmutableSet.of(ActiveRule.Inheritance.INHERITED.name())),
- new QueryOptions()
+ new QueryContext()
);
assertThat(result.getHits()).hasSize(2);
result = index.search(new RuleQuery().setActivation(true)
.setQProfileKey(qualityProfileDto1.getKey())
.setInheritance(ImmutableSet.of(ActiveRule.Inheritance.OVERRIDES.name())),
- new QueryOptions()
+ new QueryContext()
);
assertThat(result.getHits()).hasSize(0);
result = index.search(new RuleQuery().setActivation(true)
.setQProfileKey(qualityProfileDto2.getKey())
.setInheritance(ImmutableSet.of(ActiveRule.Inheritance.OVERRIDES.name())),
- new QueryOptions()
+ new QueryContext()
);
assertThat(result.getHits()).hasSize(1);
.setQProfileKey(qualityProfileDto1.getKey())
.setInheritance(ImmutableSet.of(
ActiveRule.Inheritance.INHERITED.name(), ActiveRule.Inheritance.OVERRIDES.name())),
- new QueryOptions()
+ new QueryContext()
);
assertThat(result.getHits()).hasSize(0);
.setQProfileKey(qualityProfileDto2.getKey())
.setInheritance(ImmutableSet.of(
ActiveRule.Inheritance.INHERITED.name(), ActiveRule.Inheritance.OVERRIDES.name())),
- new QueryOptions()
+ new QueryContext()
);
assertThat(result.getHits()).hasSize(3);
}
// find all
RuleQuery query = new RuleQuery();
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
// tag1 in query
query = new RuleQuery().setQueryText("tag1");
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(1);
- assertThat(Iterables.getFirst(index.search(query, new QueryOptions()).getHits(), null).tags()).containsExactly("tag1");
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
+ assertThat(Iterables.getFirst(index.search(query, new QueryContext()).getHits(), null).tags()).containsExactly("tag1");
// tag1 and tag2 in query
query = new RuleQuery().setQueryText("tag1 tag2");
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
// tag2 in filter
query = new RuleQuery().setTags(ImmutableSet.of("tag2"));
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(1);
- assertThat(Iterables.getFirst(index.search(query, new QueryOptions()).getHits(), null).tags()).containsExactly("tag2");
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
+ assertThat(Iterables.getFirst(index.search(query, new QueryContext()).getHits(), null).tags()).containsExactly("tag2");
// tag2 in filter and tag1 tag2 in query
query = new RuleQuery().setTags(ImmutableSet.of("tag2")).setQueryText("tag1");
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(0);
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(0);
// tag2 in filter and tag1 in query
query = new RuleQuery().setTags(ImmutableSet.of("tag2")).setQueryText("tag1 tag2");
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(1);
- assertThat(Iterables.getFirst(index.search(query, new QueryOptions()).getHits(), null).tags()).containsExactly("tag2");
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
+ assertThat(Iterables.getFirst(index.search(query, new QueryContext()).getHits(), null).tags()).containsExactly("tag2");
// null list => no filter
query = new RuleQuery().setTags(Collections.<String>emptySet());
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
// null list => no filter
query = new RuleQuery().setTags(null);
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
}
@Test
// find all
RuleQuery query = new RuleQuery();
- Result<Rule> results = index.search(query, new QueryOptions());
+ Result<Rule> results = index.search(query, new QueryContext());
assertThat(results.getHits()).hasSize(2);
// Only template
query = new RuleQuery().setIsTemplate(true);
- results = index.search(query, new QueryOptions());
+ results = index.search(query, new QueryContext());
assertThat(results.getHits()).hasSize(1);
assertThat(Iterables.getFirst(results.getHits(), null).key().rule()).isEqualTo("S002");
assertThat(Iterables.getFirst(results.getHits(), null).isTemplate()).isTrue();
// Only not template
query = new RuleQuery().setIsTemplate(false);
- results = index.search(query, new QueryOptions());
+ results = index.search(query, new QueryContext());
assertThat(results.getHits()).hasSize(1);
assertThat(Iterables.getFirst(results.getHits(), null).isTemplate()).isFalse();
assertThat(Iterables.getFirst(results.getHits(), null).key().rule()).isEqualTo("S001");
// null => no filter
query = new RuleQuery().setIsTemplate(null);
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
}
@Test
// find all
RuleQuery query = new RuleQuery();
- Result<Rule> results = index.search(query, new QueryOptions());
+ Result<Rule> results = index.search(query, new QueryContext());
assertThat(results.getHits()).hasSize(2);
// Only custom rule
query = new RuleQuery().setTemplateKey("java:S001");
- results = index.search(query, new QueryOptions());
+ results = index.search(query, new QueryContext());
assertThat(results.getHits()).hasSize(1);
assertThat(Iterables.getFirst(results.getHits(), null).key().rule()).isEqualTo("S001_MY_CUSTOM");
assertThat(Iterables.getFirst(results.getHits(), null).templateKey()).isEqualTo(RuleKey.of("java", "S001"));
// null => no filter
query = new RuleQuery().setTemplateKey(null);
- assertThat(index.search(query, new QueryOptions()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
}
@Test
// find all
RuleQuery query = new RuleQuery();
- Result<Rule> results = index.search(query, new QueryOptions());
+ Result<Rule> results = index.search(query, new QueryContext());
assertThat(results.getHits()).hasSize(2);
// get params
// find all
RuleQuery query = new RuleQuery();
- Result<Rule> results = index.search(query, new QueryOptions());
+ Result<Rule> results = index.search(query, new QueryContext());
assertThat(results.getHits()).hasSize(2);
// find custom rule
dbSession.commit();
// from 0 to 1 included
- QueryOptions options = new QueryOptions();
+ QueryContext options = new QueryContext();
options.setOffset(0).setLimit(2);
Result results = index.search(new RuleQuery(), options);
assertThat(results.getTotal()).isEqualTo(3);
dbSession.commit();
// 0. find all rules;
- assertThat(index.search(new RuleQuery(), new QueryOptions()).getHits()).hasSize(2);
+ assertThat(index.search(new RuleQuery(), new QueryContext()).getHits()).hasSize(2);
// 1. find all rules available since a date;
RuleQuery availableSinceQuery = new RuleQuery()
.setAvailableSince(since);
- List<Rule> hits = index.search(availableSinceQuery, new QueryOptions()).getHits();
+ List<Rule> hits = index.search(availableSinceQuery, new QueryContext()).getHits();
assertThat(hits).hasSize(1);
assertThat(hits.get(0).key()).isEqualTo(RuleKey.of("java", "S002"));
// 2. find no new rules since tomorrow.
RuleQuery availableSinceNowQuery = new RuleQuery()
.setAvailableSince(DateUtils.addDays(since, 1));
- assertThat(index.search(availableSinceNowQuery, new QueryOptions()).getHits()).hasSize(0);
+ assertThat(index.search(availableSinceNowQuery, new QueryContext()).getHits()).hasSize(0);
}
@Test
assertThat(rule.name()).isEqualTo(nameWithProtectedChars);
RuleQuery protectedCharsQuery = new RuleQuery().setQueryText(nameWithProtectedChars);
- List<Rule> results = index.search(protectedCharsQuery, new QueryOptions()).getHits();
+ List<Rule> results = index.search(protectedCharsQuery, new QueryContext()).getHits();
assertThat(results).hasSize(1);
assertThat(results.get(0).key()).isEqualTo(RuleTesting.XOO_X1);
}
import org.sonar.api.server.debt.DebtModel;
import org.sonar.api.server.ws.internal.SimpleGetRequest;
import org.sonar.server.rule.index.RuleNormalizer;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.search.ws.SearchOptions;
import org.sonar.server.text.MacroInterpreter;
SimpleGetRequest request = new SimpleGetRequest();
request.setParam("p", "1");
request.setParam("ps", "10");
- QueryOptions queryOptions = mapping.newQueryOptions(SearchOptions.create(request));
+ QueryContext queryContext = mapping.newQueryOptions(SearchOptions.create(request));
- assertThat(queryOptions.getFieldsToReturn()).isEmpty();
+ assertThat(queryContext.getFieldsToReturn()).isEmpty();
}
@Test
request.setParam("p", "1");
request.setParam("ps", "10");
request.setParam("f", "repo,name,lang");
- QueryOptions queryOptions = mapping.newQueryOptions(SearchOptions.create(request));
+ QueryContext queryContext = mapping.newQueryOptions(SearchOptions.create(request));
- assertThat(queryOptions.getFieldsToReturn()).containsOnly(
+ assertThat(queryContext.getFieldsToReturn()).containsOnly(
RuleNormalizer.RuleField.REPOSITORY.field(),
RuleNormalizer.RuleField.NAME.field(),
RuleNormalizer.RuleField.LANGUAGE.field());
request.setParam("p", "1");
request.setParam("ps", "10");
request.setParam("f", "langName");
- QueryOptions queryOptions = mapping.newQueryOptions(SearchOptions.create(request));
+ QueryContext queryContext = mapping.newQueryOptions(SearchOptions.create(request));
- assertThat(queryOptions.getFieldsToReturn()).containsOnly(RuleNormalizer.RuleField.LANGUAGE.field());
+ assertThat(queryContext.getFieldsToReturn()).containsOnly(RuleNormalizer.RuleField.LANGUAGE.field());
}
@Test
request.setParam("p", "1");
request.setParam("ps", "10");
request.setParam("f", "debtRemFn");
- QueryOptions queryOptions = mapping.newQueryOptions(SearchOptions.create(request));
+ QueryContext queryContext = mapping.newQueryOptions(SearchOptions.create(request));
- assertThat(queryOptions.getFieldsToReturn()).containsOnly(
+ assertThat(queryContext.getFieldsToReturn()).containsOnly(
RuleNormalizer.RuleField.DEBT_FUNCTION_COEFFICIENT.field(),
RuleNormalizer.RuleField.DEBT_FUNCTION_OFFSET.field(),
RuleNormalizer.RuleField.DEBT_FUNCTION_TYPE.field(),
request.setParam("p", "1");
request.setParam("ps", "10");
request.setParam("f", "htmlNote");
- QueryOptions queryOptions = mapping.newQueryOptions(SearchOptions.create(request));
+ QueryContext queryContext = mapping.newQueryOptions(SearchOptions.create(request));
- assertThat(queryOptions.getFieldsToReturn()).containsOnly(RuleNormalizer.RuleField.NOTE.field());
+ assertThat(queryContext.getFieldsToReturn()).containsOnly(RuleNormalizer.RuleField.NOTE.field());
}
@Test
request.setParam("p", "1");
request.setParam("ps", "10");
request.setParam("f", "debtChar");
- QueryOptions queryOptions = mapping.newQueryOptions(SearchOptions.create(request));
+ QueryContext queryContext = mapping.newQueryOptions(SearchOptions.create(request));
- assertThat(queryOptions.getFieldsToReturn()).containsOnly(
+ assertThat(queryContext.getFieldsToReturn()).containsOnly(
RuleNormalizer.RuleField.CHARACTERISTIC.field(),
RuleNormalizer.RuleField.DEFAULT_CHARACTERISTIC.field());
}
--- /dev/null
+/*
+ * SonarQube, open source software quality management tool.
+ * Copyright (C) 2008-2014 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.search;
+
+import com.google.common.collect.ImmutableList;
+import org.junit.Before;
+import org.junit.Test;
+import org.sonar.server.user.MockUserSession;
+
+import java.util.Arrays;
+
+import static org.fest.assertions.Assertions.assertThat;
+import static org.fest.assertions.Fail.fail;
+
+public class QueryContextTest {
+
+ QueryContext options;
+
+ @Before
+ public void setUp() throws Exception {
+ MockUserSession.set().setLogin("john").setUserGroups("sonar-users");
+ options = new QueryContext();
+ }
+
+ @Test
+ public void user_and_groups() throws Exception {
+ assertThat(options.getUserLogin()).isEqualTo("john");
+ assertThat(options.getUserGroups()).containsOnly("sonar-users", "Anyone");
+ }
+
+ @Test
+ public void page_shortcut_for_limit_and_offset() throws Exception {
+ options.setPage(3, 10);
+
+ assertThat(options.getLimit()).isEqualTo(10);
+ assertThat(options.getOffset()).isEqualTo(20);
+ }
+
+ @Test
+ public void page_starts_at_one() throws Exception {
+ options.setPage(1, 10);
+ assertThat(options.getLimit()).isEqualTo(10);
+ assertThat(options.getOffset()).isEqualTo(0);
+ }
+
+ @Test
+ public void page_must_be_strictly_positive() throws Exception {
+ try {
+ options.setPage(0, 10);
+ fail();
+ } catch (IllegalArgumentException e) {
+ assertThat(e).hasMessage("Page must be greater or equal to 1 (got 0)");
+ }
+ }
+
+ @Test
+ public void page_size_must_be_positive() throws Exception {
+ try {
+ options.setPage(2, -1);
+ fail();
+ } catch (IllegalArgumentException e) {
+ assertThat(e).hasMessage("Page size must be greater or equal to 0 (got -1)");
+ }
+ }
+
+ @Test
+ public void max_limit() throws Exception {
+ options.setLimit(42);
+ assertThat(options.getLimit()).isEqualTo(42);
+
+ options.setLimit(QueryContext.MAX_LIMIT + 10);
+ assertThat(options.getLimit()).isEqualTo(QueryContext.MAX_LIMIT);
+ }
+
+ @Test
+ public void set_max_limit() throws Exception {
+ options.setMaxLimit();
+ assertThat(options.getLimit()).isEqualTo(QueryContext.MAX_LIMIT);
+ }
+
+ @Test
+ public void max_page_size() throws Exception {
+ options.setPage(3, QueryContext.MAX_LIMIT + 10);
+ assertThat(options.getOffset()).isEqualTo(QueryContext.MAX_LIMIT * 2);
+ assertThat(options.getLimit()).isEqualTo(QueryContext.MAX_LIMIT);
+ }
+
+
+ @Test
+ public void getFieldsToReturn() throws Exception {
+ assertThat(options.getFieldsToReturn()).isEmpty();
+
+ options.setFieldsToReturn(Arrays.asList("one", "two"));
+ assertThat(options.getFieldsToReturn()).containsOnly("one", "two");
+
+ options.addFieldsToReturn(Arrays.asList("three"));
+ assertThat(options.getFieldsToReturn()).containsOnly("one", "two", "three");
+
+ options.addFieldsToReturn("four");
+ assertThat(options.getFieldsToReturn()).containsOnly("one", "two", "three", "four");
+ }
+
+ @Test
+ public void support_immutable_fields() throws Exception {
+ options.setFieldsToReturn(ImmutableList.of("one", "two"));
+ assertThat(options.getFieldsToReturn()).containsOnly("one", "two");
+
+ options.addFieldsToReturn(ImmutableList.of("three"));
+ assertThat(options.getFieldsToReturn()).containsOnly("one", "two", "three");
+
+ options.addFieldsToReturn("four");
+ assertThat(options.getFieldsToReturn()).containsOnly("one", "two", "three", "four");
+ }
+
+ @Test
+ public void do_not_request_facets_by_default() throws Exception {
+ assertThat(options.isFacet()).isFalse();
+
+ options.setFacet(true);
+ assertThat(options.isFacet()).isTrue();
+ }
+}
+++ /dev/null
-/*
- * SonarQube, open source software quality management tool.
- * Copyright (C) 2008-2014 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.search;
-
-import com.google.common.collect.ImmutableList;
-import org.junit.Test;
-
-import java.util.Arrays;
-
-import static org.fest.assertions.Assertions.assertThat;
-import static org.fest.assertions.Fail.fail;
-
-public class QueryOptionsTest {
-
- QueryOptions options = new QueryOptions();
-
- @Test
- public void page_shortcut_for_limit_and_offset() throws Exception {
- options.setPage(3, 10);
-
- assertThat(options.getLimit()).isEqualTo(10);
- assertThat(options.getOffset()).isEqualTo(20);
- }
-
- @Test
- public void page_starts_at_one() throws Exception {
- options.setPage(1, 10);
- assertThat(options.getLimit()).isEqualTo(10);
- assertThat(options.getOffset()).isEqualTo(0);
- }
-
- @Test
- public void page_must_be_strictly_positive() throws Exception {
- try {
- options.setPage(0, 10);
- fail();
- } catch (IllegalArgumentException e) {
- assertThat(e).hasMessage("Page must be greater or equal to 1 (got 0)");
- }
- }
-
- @Test
- public void page_size_must_be_positive() throws Exception {
- try {
- options.setPage(2, -1);
- fail();
- } catch (IllegalArgumentException e) {
- assertThat(e).hasMessage("Page size must be greater or equal to 0 (got -1)");
- }
- }
-
- @Test
- public void max_limit() throws Exception {
- options.setLimit(42);
- assertThat(options.getLimit()).isEqualTo(42);
-
- options.setLimit(QueryOptions.MAX_LIMIT + 10);
- assertThat(options.getLimit()).isEqualTo(QueryOptions.MAX_LIMIT);
- }
-
- @Test
- public void set_max_limit() throws Exception {
- options.setMaxLimit();
- assertThat(options.getLimit()).isEqualTo(QueryOptions.MAX_LIMIT);
- }
-
- @Test
- public void max_page_size() throws Exception {
- options.setPage(3, QueryOptions.MAX_LIMIT + 10);
- assertThat(options.getOffset()).isEqualTo(QueryOptions.MAX_LIMIT * 2);
- assertThat(options.getLimit()).isEqualTo(QueryOptions.MAX_LIMIT);
- }
-
-
- @Test
- public void getFieldsToReturn() throws Exception {
- assertThat(options.getFieldsToReturn()).isEmpty();
-
- options.setFieldsToReturn(Arrays.asList("one", "two"));
- assertThat(options.getFieldsToReturn()).containsOnly("one", "two");
-
- options.addFieldsToReturn(Arrays.asList("three"));
- assertThat(options.getFieldsToReturn()).containsOnly("one", "two", "three");
-
- options.addFieldsToReturn("four");
- assertThat(options.getFieldsToReturn()).containsOnly("one", "two", "three", "four");
- }
-
- @Test
- public void support_immutable_fields() throws Exception {
- options.setFieldsToReturn(ImmutableList.of("one", "two"));
- assertThat(options.getFieldsToReturn()).containsOnly("one", "two");
-
- options.addFieldsToReturn(ImmutableList.of("three"));
- assertThat(options.getFieldsToReturn()).containsOnly("one", "two", "three");
-
- options.addFieldsToReturn("four");
- assertThat(options.getFieldsToReturn()).containsOnly("one", "two", "three", "four");
- }
-
- @Test
- public void do_not_request_facets_by_default() throws Exception {
- assertThat(options.isFacet()).isFalse();
-
- options.setFacet(true);
- assertThat(options.isFacet()).isTrue();
- }
-}
import org.sonar.api.server.ws.WebService;
import org.sonar.api.server.ws.internal.SimpleGetRequest;
import org.sonar.api.utils.text.JsonWriter;
-import org.sonar.server.search.QueryOptions;
+import org.sonar.server.search.QueryContext;
import org.sonar.server.search.Result;
import java.io.StringWriter;
assertThat(page.defaultValue()).isEqualTo("1");
WebService.Param pageSize = searchAction.param("ps");
assertThat(pageSize).isNotNull();
- assertThat(pageSize.defaultValue()).isEqualTo("" + QueryOptions.DEFAULT_LIMIT);
+ assertThat(pageSize.defaultValue()).isEqualTo("" + QueryContext.DEFAULT_LIMIT);
}
}
return this;
}
+ public MockUserSession setUserGroups(@Nullable String... userGroups) {
+ super.setUserGroups(userGroups);
+ return this;
+ }
+
public MockUserSession setGlobalPermissions(String... globalPermissions) {
this.globalPermissions = Arrays.asList(globalPermissions);
return this;
public class MockUserSessionTest {
@Test
public void set_mock_session() {
- MockUserSession.set().setLogin("simon");
+ MockUserSession.set().setLogin("simon").setUserGroups("sonar-users");
UserSession mock = UserSession.get();
assertThat(mock.login()).isEqualTo("simon");
+ assertThat(mock.userGroups()).containsOnly("sonar-users", "Anyone");
assertThat(mock.globalPermissions()).isEmpty();
assertThat(mock.isLoggedIn()).isTrue();
}
import java.util.Locale;
+import static com.google.common.collect.Lists.newArrayList;
import static org.fest.assertions.Assertions.assertThat;
public class RubyUserSessionTest {
@Test
public void should_set_session() throws Exception {
- RubyUserSession.setSession(123, "karadoc", "Karadoc", "fr");
+ RubyUserSession.setSession(123, "karadoc", "Karadoc", newArrayList("sonar-users"), "fr");
UserSession session = UserSession.get();
assertThat(session.login()).isEqualTo("karadoc");
assertThat(session.name()).isEqualTo("Karadoc");
assertThat(session.userId()).isEqualTo(123);
+ assertThat(session.userGroups()).containsOnly("sonar-users", "Anyone");
assertThat(session.isLoggedIn()).isTrue();
assertThat(session.locale()).isEqualTo(Locale.FRENCH);
}
@Test
public void should_set_anonymous_session() throws Exception {
- RubyUserSession.setSession(null, null, null, "fr");
+ RubyUserSession.setSession(null, null, null, null, "fr");
UserSession session = UserSession.get();
assertThat(session.login()).isNull();
assertThat(session.name()).isNull();
assertThat(session.userId()).isNull();
+ assertThat(session.userGroups()).containsOnly("Anyone");
assertThat(session.isLoggedIn()).isFalse();
assertThat(session.locale()).isEqualTo(Locale.FRENCH);
}
-
}
assertThat(group.getUpdatedAt()).isEqualTo(DateUtils.parseDate("2014-09-08"));
}
+ @Test
+ public void find_by_user_login() throws Exception {
+ setupData("find_by_user_login");
+
+ assertThat(dao.findByUserLogin(session, "john")).hasSize(2);
+ assertThat(dao.findByUserLogin(session, "max")).isEmpty();
+ }
+
@Test
public void insert() throws Exception {
when(system2.now()).thenReturn(DateUtils.parseDate("2014-09-08").getTime());
--- /dev/null
+<!--
+ ~ SonarQube, open source software quality management tool.
+ ~ Copyright (C) 2008-2014 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.
+ -->
+
+<dataset>
+
+ <groups id="1" name="sonar-users" description="Sonar Users" created_at="2014-09-07" updated_at="2014-09-08"/>
+ <groups id="2" name="sonar-admins" description="Sonar Admins" created_at="2014-09-07" updated_at="2014-09-08"/>
+ <groups id="3" name="sonar-reviewers" description="Sonar Reviewers" created_at="2014-09-07" updated_at="2014-09-08"/>
+
+ <groups_users user_id="100" group_id="1"/>
+ <groups_users user_id="100" group_id="2"/>
+
+ <users id="100" login="john" name="John" email="jo@hn.com" created_at="2014-06-20" updated_at="2014-06-20" active="[true]"/>
+
+</dataset>
end
if current_user && current_user.id
- Java::OrgSonarServerUser::RubyUserSession.setSession(current_user.id.to_i, current_user.login, current_user.name, I18n.locale.to_s)
+ user_groups_name = current_user.groups.collect {|g| g.name}.to_a
+ Java::OrgSonarServerUser::RubyUserSession.setSession(current_user.id.to_i, current_user.login, current_user.name, user_groups_name, I18n.locale.to_s)
else
- Java::OrgSonarServerUser::RubyUserSession.setSession(nil, nil, nil, I18n.locale.to_s)
+ Java::OrgSonarServerUser::RubyUserSession.setSession(nil, nil, nil, nil, I18n.locale.to_s)
end
end
IssueAuthorizationDto selectByKey(String key);
- IssueAuthorizationDto selectAfterDate(@Param("date") Date date, @Param("permission") String permission);
+ IssueAuthorizationDto selectAfterDate(@Param("date") Date date, @Param("permission") String permission, @Param("anyone") String anyoneGroup);
}
import javax.annotation.CheckForNull;
+import java.util.List;
+
public interface GroupMapper {
@CheckForNull
GroupDto selectByKey(String name);
+ List<GroupDto> selectByUserLogin(String userLogin);
+
void insert(GroupDto groupDto);
}
SELECT
projects.kee AS project,
NULL AS login,
- 'anyone' AS permission_group,
+ #{anyone} AS permission_group,
group_roles.role as permission_role
FROM projects
INNER JOIN group_roles ON group_roles.resource_id = projects.id AND group_roles.role = #{permission}
<select id="selectByKey" parameterType="string" resultType="Group">
SELECT <include refid="groupColumns"/>
- FROM groups g WHERE g.name=#{id}
+ FROM groups g
+ <where>
+ g.name=#{id}
+ </where>
+ </select>
+
+ <select id="selectByUserLogin" parameterType="string" resultType="Group">
+ SELECT <include refid="groupColumns"/>
+ FROM groups g
+ INNER JOIN groups_users gu on gu.group_id=g.id
+ INNER JOIN users u on u.id=gu.user_id
+ <where>
+ u.login=#{login}
+ </where>
</select>
<insert id="insert" parameterType="Group" keyColumn="id" useGeneratedKeys="true" keyProperty="id">
projects / sonarqube.git / commitdiff