import static org.sonar.server.component.ws.FilterParser.Operator.EQ;
import static org.sonar.server.component.ws.FilterParser.Operator.IN;
import static org.sonar.server.measure.index.ProjectMeasuresQuery.MetricCriterion;
-import static org.sonarqube.ws.client.project.ProjectsWsParameters.FILTER_LANGUAGE;
+import static org.sonarqube.ws.client.project.ProjectsWsParameters.FILTER_LANGUAGES;
class ProjectMeasuresQueryFactory {
private static final Map<String, BiConsumer<Criterion, ProjectMeasuresQuery>> CRITERION_PROCESSORS = ImmutableMap.<String, BiConsumer<Criterion, ProjectMeasuresQuery>>builder()
.put(IS_FAVORITE_CRITERION.toLowerCase(ENGLISH), (criterion, query) -> processIsFavorite(criterion))
- .put(FILTER_LANGUAGE, ProjectMeasuresQueryFactory::processLanguages)
+ .put(FILTER_LANGUAGES, ProjectMeasuresQueryFactory::processLanguages)
.put(CRITERION_TAG, ProjectMeasuresQueryFactory::processTags)
.put(QUERY_KEY, ProjectMeasuresQueryFactory::processQuery)
.put(ALERT_STATUS_KEY, ProjectMeasuresQueryFactory::processQualityGateStatus)
query.setLanguages(new HashSet<>(values));
return;
}
- throw new IllegalArgumentException("Language should be set either by using 'language = java' or 'language IN (java, js)'");
+ throw new IllegalArgumentException("Languages should be set either by using 'languages = java' or 'languages IN (java, js)'");
}
private static void processTags(Criterion criterion, ProjectMeasuresQuery query) {
import static org.sonarqube.ws.client.component.ComponentsWsParameters.PARAM_ORGANIZATION;
import static org.sonarqube.ws.client.component.SearchProjectsRequest.DEFAULT_PAGE_SIZE;
import static org.sonarqube.ws.client.component.SearchProjectsRequest.MAX_PAGE_SIZE;
-import static org.sonarqube.ws.client.project.ProjectsWsParameters.FILTER_LANGUAGE;
+import static org.sonarqube.ws.client.project.ProjectsWsParameters.FILTER_LANGUAGES;
public class SearchProjectsAction implements ComponentsWsAction {
.addPagingParams(DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE)
.setInternal(true)
.setResponseExample(getClass().getResource("search_projects-example.json"))
- .setChangelog(new Change("6.4", format("The '%s' parameter accepts '%s' to filter by language", FILTER_LANGUAGE, PARAM_FILTER)))
+ .setChangelog(new Change("6.4", format("The '%s' parameter accepts '%s' to filter by language", FILTER_LANGUAGES, PARAM_FILTER)))
.setHandler(this);
action.createFieldsParam(POSSIBLE_FIELDS)
import static org.sonar.server.measure.index.ProjectMeasuresIndexDefinition.FIELD_TAGS;
import static org.sonar.server.measure.index.ProjectMeasuresIndexDefinition.INDEX_TYPE_PROJECT_MEASURES;
import static org.sonar.server.measure.index.ProjectMeasuresQuery.SORT_BY_NAME;
-import static org.sonarqube.ws.client.project.ProjectsWsParameters.FILTER_LANGUAGE;
+import static org.sonarqube.ws.client.project.ProjectsWsParameters.FILTER_LANGUAGES;
public class ProjectMeasuresIndex extends BaseIndex {
RELIABILITY_RATING_KEY,
SECURITY_RATING_KEY,
ALERT_STATUS_KEY,
- FILTER_LANGUAGE,
+ FILTER_LANGUAGES,
FIELD_TAGS);
private static final String FIELD_MEASURES_KEY = FIELD_MEASURES + "." + ProjectMeasuresIndexDefinition.FIELD_MEASURES_KEY;
.put(RELIABILITY_RATING_KEY, (esSearch, filters) -> addRatingFacet(esSearch, RELIABILITY_RATING_KEY, filters))
.put(SECURITY_RATING_KEY, (esSearch, filters) -> addRatingFacet(esSearch, SECURITY_RATING_KEY, filters))
.put(ALERT_STATUS_KEY, (esSearch, filters) -> esSearch.addAggregation(createStickyFacet(ALERT_STATUS_KEY, filters, createQualityGateFacet())))
- .put(FILTER_LANGUAGE, (esSearch, filters) -> esSearch.addAggregation(createStickyFacet(FILTER_LANGUAGE, filters, createLanguagesFacet())))
+ .put(FILTER_LANGUAGES, (esSearch, filters) -> esSearch.addAggregation(createStickyFacet(FILTER_LANGUAGES, filters, createLanguagesFacet())))
.put(FIELD_TAGS, (esSearch, filters) -> esSearch.addAggregation(createStickyFacet(FIELD_TAGS, filters, createTagsFacet())))
.build();
}
private static AbstractAggregationBuilder createLanguagesFacet() {
- return AggregationBuilders.terms(FILTER_LANGUAGE).field(FIELD_LANGUAGES);
+ return AggregationBuilders.terms(FILTER_LANGUAGES).field(FIELD_LANGUAGES);
}
private static AbstractAggregationBuilder createTagsFacet() {
.ifPresent(projectUuids -> filters.put("ids", termsQuery("_id", projectUuids)));
query.getLanguages()
- .ifPresent(languages -> filters.put(FILTER_LANGUAGE, termsQuery(FIELD_LANGUAGES, languages)));
+ .ifPresent(languages -> filters.put(FILTER_LANGUAGES, termsQuery(FIELD_LANGUAGES, languages)));
query.getOrganizationUuid()
.ifPresent(organizationUuid -> filters.put(FIELD_ORGANIZATION_UUID, termQuery(FIELD_ORGANIZATION_UUID, organizationUuid)));
@Test
public void create_query_on_language_using_in_operator() throws Exception {
ProjectMeasuresQuery query = newProjectMeasuresQuery(
- singletonList(Criterion.builder().setKey("language").setOperator(IN).setValues(asList("java", "js")).build()),
+ singletonList(Criterion.builder().setKey("languages").setOperator(IN).setValues(asList("java", "js")).build()),
emptySet());
assertThat(query.getLanguages().get()).containsOnly("java", "js");
@Test
public void create_query_on_language_using_equals_operator() throws Exception {
ProjectMeasuresQuery query = newProjectMeasuresQuery(
- singletonList(Criterion.builder().setKey("language").setOperator(EQ).setValue("java").build()),
+ singletonList(Criterion.builder().setKey("languages").setOperator(EQ).setValue("java").build()),
emptySet());
assertThat(query.getLanguages().get()).containsOnly("java");
@Test
public void fail_to_create_query_on_language_using_in_operator_and_value() throws Exception {
expectedException.expect(IllegalArgumentException.class);
- expectedException.expectMessage("Language should be set either by using 'language = java' or 'language IN (java, js)");
+ expectedException.expectMessage("Languages should be set either by using 'languages = java' or 'languages IN (java, js)");
- newProjectMeasuresQuery(singletonList(Criterion.builder().setKey("language").setOperator(IN).setValue("java").build()), emptySet());
+ newProjectMeasuresQuery(singletonList(Criterion.builder().setKey("languages").setOperator(IN).setValue("java").build()), emptySet());
}
@Test
public void fail_to_create_query_on_language_using_eq_operator_and_values() throws Exception {
expectedException.expect(IllegalArgumentException.class);
- expectedException.expectMessage("Language should be set either by using 'language = java' or 'language IN (java, js)");
+ expectedException.expectMessage("Languages should be set either by using 'languages = java' or 'languages IN (java, js)");
- newProjectMeasuresQuery(singletonList(Criterion.builder().setKey("language").setOperator(EQ).setValues(asList("java")).build()), emptySet());
+ newProjectMeasuresQuery(singletonList(Criterion.builder().setKey("languages").setOperator(EQ).setValues(asList("java")).build()), emptySet());
}
-
@Test
public void create_query_on_tag_using_in_operator() throws Exception {
ProjectMeasuresQuery query = newProjectMeasuresQuery(
import static org.sonar.test.JsonAssert.assertJson;
import static org.sonarqube.ws.client.component.ComponentsWsParameters.PARAM_FILTER;
import static org.sonarqube.ws.client.component.ComponentsWsParameters.PARAM_ORGANIZATION;
-import static org.sonarqube.ws.client.project.ProjectsWsParameters.FILTER_LANGUAGE;
+import static org.sonarqube.ws.client.project.ProjectsWsParameters.FILTER_LANGUAGES;
public class SearchProjectsActionTest {
Param additionalFields = def.param("f");
assertThat(additionalFields.defaultValue()).isNull();
assertThat(additionalFields.possibleValues()).containsOnly("analysisDate");
+
+ Param facets = def.param("facets");
+ assertThat(facets.defaultValue()).isNull();
+ assertThat(facets.possibleValues()).containsOnly("ncloc", "duplicated_lines_density", "coverage", "sqale_rating", "reliability_rating", "security_rating", "alert_status",
+ "languages", "tags");
}
@Test
public void filter_projects_by_languages() {
OrganizationDto organizationDto = db.organizations().insertForKey("my-org-key-1");
insertProjectInDbAndEs(newProjectDto(organizationDto).setName("Sonar Java"), newArrayList(newMeasure(COVERAGE, 81d)), null, asList("<null>", "java", "xoo"));
- insertProjectInDbAndEs(newProjectDto(organizationDto).setName("Sonar Groovy"), newArrayList(newMeasure(COVERAGE, 81)), null,asList("java", "xoo"));
+ insertProjectInDbAndEs(newProjectDto(organizationDto).setName("Sonar Groovy"), newArrayList(newMeasure(COVERAGE, 81)), null, asList("java", "xoo"));
insertProjectInDbAndEs(newProjectDto(organizationDto).setName("Sonar Markdown"), newArrayList(newMeasure(COVERAGE, 80d)), null, asList("xoo"));
insertProjectInDbAndEs(newProjectDto(organizationDto).setName("Sonar Qube"), newArrayList(newMeasure(COVERAGE, 80d)), null, asList("<null>", "java", "xoo"));
insertMetrics(COVERAGE, NCLOC_LANGUAGE_DISTRIBUTION_KEY);
- request.setFilter("language IN (java, js, <null>)");
+ request.setFilter("languages IN (java, js, <null>)");
SearchProjectsWsResponse result = call(request);
insertProjectInDbAndEs(newProjectDto(organization).setName("Sonar Qube"), newArrayList(newMeasure(COVERAGE, 80d)), null, asList("<null>", "java", "xoo"));
insertMetrics(COVERAGE, NCLOC_LANGUAGE_DISTRIBUTION_KEY);
- SearchProjectsWsResponse result = call(request.setFacets(singletonList(FILTER_LANGUAGE)));
+ SearchProjectsWsResponse result = call(request.setFacets(singletonList(FILTER_LANGUAGES)));
Common.Facet facet = result.getFacets().getFacetsList().stream()
- .filter(oneFacet -> FILTER_LANGUAGE.equals(oneFacet.getProperty()))
+ .filter(oneFacet -> FILTER_LANGUAGES.equals(oneFacet.getProperty()))
.findFirst().orElseThrow(IllegalStateException::new);
- assertThat(facet.getProperty()).isEqualTo(FILTER_LANGUAGE);
+ assertThat(facet.getProperty()).isEqualTo(FILTER_LANGUAGES);
assertThat(facet.getValuesList())
.extracting(Common.FacetValue::getVal, Common.FacetValue::getCount)
.containsExactly(
private static final String COVERAGE = "coverage";
private static final String DUPLICATION = "duplicated_lines_density";
private static final String NCLOC = "ncloc";
- private static final String LANGUAGE = "language";
+ private static final String LANGUAGES = "languages";
private static final OrganizationDto ORG = OrganizationTesting.newOrganizationDto();
private static final ComponentDto PROJECT1 = newProjectDto(ORG).setUuid("Project-1").setName("Project 1").setKey("key-1");
}
@Test
- public void facet_language() {
+ public void facet_languages() {
index(
newDoc().setLanguages(singletonList("java")),
newDoc().setLanguages(singletonList("java")),
newDoc().setLanguages(asList("<null>", "java")),
newDoc().setLanguages(asList("<null>", "java", "xoo")));
- Facets facets = underTest.search(new ProjectMeasuresQuery(), new SearchOptions().addFacets(LANGUAGE)).getFacets();
+ Facets facets = underTest.search(new ProjectMeasuresQuery(), new SearchOptions().addFacets(LANGUAGES)).getFacets();
- assertThat(facets.get(LANGUAGE)).containsOnly(
+ assertThat(facets.get(LANGUAGES)).containsOnly(
entry("<null>", 2L),
entry("java", 4L),
entry("xoo", 2L),
}
@Test
- public void facet_language_is_limited_to_10_languages() {
+ public void facet_languages_is_limited_to_10_languages() {
index(
newDoc().setLanguages(asList("<null>", "java", "xoo", "css", "cpp")),
newDoc().setLanguages(asList("xml", "php", "python", "perl", "ruby")),
newDoc().setLanguages(asList("js", "scala")));
- Facets facets = underTest.search(new ProjectMeasuresQuery(), new SearchOptions().addFacets(LANGUAGE)).getFacets();
+ Facets facets = underTest.search(new ProjectMeasuresQuery(), new SearchOptions().addFacets(LANGUAGES)).getFacets();
- assertThat(facets.get(LANGUAGE)).hasSize(10);
+ assertThat(facets.get(LANGUAGES)).hasSize(10);
}
@Test
- public void facet_language_is_sticky() {
+ public void facet_languages_is_sticky() {
index(
newDoc(NCLOC, 10d).setLanguages(singletonList("java")),
newDoc(NCLOC, 10d).setLanguages(singletonList("java")),
Facets facets = underTest.search(
new ProjectMeasuresQuery().setLanguages(ImmutableSet.of("java")),
- new SearchOptions().addFacets(LANGUAGE, NCLOC)).getFacets();
+ new SearchOptions().addFacets(LANGUAGES, NCLOC)).getFacets();
// Sticky facet on language does not take into account language filter
- assertThat(facets.get(LANGUAGE)).containsOnly(
+ assertThat(facets.get(LANGUAGES)).containsOnly(
entry("<null>", 2L),
entry("java", 4L),
entry("xoo", 2L),
newDoc().setLanguages(asList("java", "xoo")));
userSession.logIn(USER1);
- LinkedHashMap<String, Long> result = underTest.search(new ProjectMeasuresQuery(), new SearchOptions().addFacets(LANGUAGE)).getFacets().get(LANGUAGE);
+ LinkedHashMap<String, Long> result = underTest.search(new ProjectMeasuresQuery(), new SearchOptions().addFacets(LANGUAGES)).getFacets().get(LANGUAGES);
assertThat(result).containsOnly(
entry("java", 2L),
public static final String PARAM_TO = "to";
public static final String PARAM_DRY_RUN = "dryRun";
-
- public static final String FILTER_LANGUAGE = "language";
+ public static final String FILTER_LANGUAGES = "languages";
private ProjectsWsParameters() {
// static utils only