import org.sonar.core.component.ComponentDto;
import org.sonar.core.persistence.MyBatis;
+import javax.annotation.CheckForNull;
+
import java.util.List;
public class QualityProfileDao implements ServerComponent {
}
}
+ public List<QualityProfileDto> selectByLanguage(String language) {
+ SqlSession session = mybatis.openSession();
+ try {
+ return session.getMapper(QualityProfileMapper.class).selectByLanguage(language);
+ } finally {
+ MyBatis.closeQuietly(session);
+ }
+ }
+
+ @CheckForNull
public QualityProfileDto selectById(Integer id) {
SqlSession session = mybatis.openSession();
try {
}
}
+ @CheckForNull
public QualityProfileDto selectParent(Integer childId) {
SqlSession session = mybatis.openSession();
try {
@CheckForNull
QualityProfileDto selectById(@Param("id") Integer id);
+ List<QualityProfileDto> selectByLanguage(String language);
// INHERITANCE
List<QualityProfileDto> selectByProject(@Param("projectId") Long projectId, @Param("key") String propertyKeyPrefix);
-
}
</where>
</select>
+ <select id="selectByLanguage" parameterType="String" resultType="QualityProfile">
+ SELECT DISTINCT <include refid="profilesColumns"/>
+ FROM rules_profiles p
+ <where>
+ AND p.language=#{language}
+ </where>
+ ORDER BY p.name
+ </select>
+
<select id="selectById" parameterType="Integer" resultType="QualityProfile">
SELECT <include refid="profilesColumns"/>
FROM rules_profiles p
assertThat(dao.selectByNameAndLanguage("Sonar Way", "unknown")).isNull();
}
+ @Test
+ public void select_by_language() {
+ setupData("select_by_language");
+
+ List<QualityProfileDto> result = dao.selectByLanguage("java");
+ assertThat(result).hasSize(2);
+ assertThat(result.get(0).getName()).isEqualTo("Sonar Way 1");
+ assertThat(result.get(1).getName()).isEqualTo("Sonar Way 2");
+ }
+
@Test
public void select_by_id() {
setupData("shared");
--- /dev/null
+<dataset>
+
+ <rules_profiles id="1" name="Sonar Way 1" language="java" parent_name="[null]" version="1"
+ used_profile="[false]"/>
+
+ <rules_profiles id="2" name="Sonar Way" language="js" parent_name="[null]" version="1"
+ used_profile="[false]"/>
+
+ <rules_profiles id="3" name="Sonar Way 2" language="java" parent_name="[null]" version="1"
+ used_profile="[false]"/>
+
+</dataset>
import org.elasticsearch.common.collect.Lists;
import org.elasticsearch.common.collect.Maps;
import org.elasticsearch.common.joda.time.format.ISODateTimeFormat;
-import org.sonar.api.rules.ActiveRule;
import org.sonar.check.Cardinality;
import org.sonar.server.rule.ActiveRuleDocument;
import org.sonar.server.rule.RuleDocument;
public class QProfileRule {
+ public static final String INHERITED = "INHERITED";
+ public static final String OVERRIDES = "OVERRIDES";
+
private final Integer id;
private final Integer parentId;
private final String key;
}
public boolean isInherited() {
- return ActiveRule.INHERITED.equals(inheritance);
+ return INHERITED.equals(inheritance);
}
public boolean isOverrides() {
- return ActiveRule.OVERRIDES.equals(inheritance);
+ return OVERRIDES.equals(inheritance);
}
public boolean isTemplate() {
return toQProfiles(dao.selectAll());
}
+ public List<QProfile> profiles(String language) {
+ return toQProfiles(dao.selectByLanguage(language));
+ }
+
@CheckForNull
public QProfile defaultProfile(String language) {
QualityProfileDto dto = dao.selectDefaultProfile(language, QProfileProjectService.PROPERTY_PREFIX + language);
return toQProfiles(dao.selectChildren(profile.name(), profile.language()));
}
+ public List<QProfile> ancestors(QProfile profile) {
+ List<QProfile> ancestors = newArrayList();
+ incrementAncestors(profile, ancestors);
+ return ancestors;
+ }
+
+ private void incrementAncestors(QProfile profile, List<QProfile> ancestors){
+ if (profile.parent() != null) {
+ QualityProfileDto parentDto = dao.selectParent(profile.id());
+ if (parentDto == null) {
+ throw new IllegalStateException("Cannot find parent of profile : "+ profile.id());
+ }
+ QProfile parent = QProfile.from(parentDto);
+ ancestors.add(parent);
+ incrementAncestors(parent, ancestors);
+ }
+ }
+
public int countChildren(QProfile profile) {
return dao.countChildren(profile.name(), profile.language());
}
// ACTIVE RULES
// bulk activate all
// bulk deactivate all
- // active rule parameter validation (only Integer types are checked)
+ // active rule parameter validation (only Integer and Boolean types are checked)
public List<QProfile> allProfiles() {
return search.allProfiles();
}
+ public List<QProfile> profilesByLanguage(String language) {
+ return search.profiles(language);
+ }
+
public QProfile profile(int id) {
return QProfile.from(findNotNull(id));
}
return search.children(profile);
}
+ public List<QProfile> ancestors(QProfile profile) {
+ return search.ancestors(profile);
+ }
+
public int countChildren(QProfile profile) {
return search.countChildren(profile);
}
return rules.countProfileRules(ProfileRuleQuery.create(profile.id()));
}
+ public long countOverridingProfileRules(QProfile profile) {
+ return rules.countProfileRules(ProfileRuleQuery.create(profile.id()).setInheritance(QProfileRule.OVERRIDES));
+ }
+
public ProfileRuleChanged activateRule(int profileId, int ruleId, String severity) {
QualityProfileDto qualityProfile = findNotNull(profileId);
RuleDto rule = findRuleNotNull(ruleId);
import org.sonar.server.util.RubyUtils;
import javax.annotation.CheckForNull;
+
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
private static final String PARAM_REPOSITORY_KEYS = "repositoryKeys";
private static final String PARAM_SEVERITIES = "severities";
private static final String PARAM_STATUSES = "statuses";
+ private static final String PARAM_INHERITANCE = "inheritance";
private int profileId;
private String language;
private List<String> repositoryKeys;
private List<String> severities;
private List<String> statuses;
+ private String inheritance;
private ProfileRuleQuery() {
repositoryKeys = Lists.newArrayList();
if (params.get(PARAM_STATUSES) != null) {
result.addStatuses(optionalVarargs(params.get(PARAM_STATUSES)));
}
+ if (params.containsKey(PARAM_INHERITANCE)) {
+ result.setInheritance((String) params.get(PARAM_INHERITANCE));
+ }
if (!errors.isEmpty()) {
throw BadRequestException.of("Incorrect rule search parameters", errors);
return this;
}
+ public ProfileRuleQuery setInheritance(String inheritance) {
+ this.inheritance = inheritance;
+ return this;
+ }
+
+
public int profileId() {
return profileId;
}
return ImmutableList.copyOf(statuses);
}
+ @CheckForNull
+ public String inheritance() {
+ return inheritance;
+ }
+
private static String[] optionalVarargs(Object jRubyArray) {
List<String> items = RubyUtils.toStrings(jRubyArray);
String[] empty = new String[0];
hasParentFilter(TYPE_RULE, parentRuleFilter(query))
);
addMustTermOrTerms(filter, ActiveRuleDocument.FIELD_SEVERITY, query.severities());
+ String inheritance = query.inheritance();
+ if (inheritance != null) {
+ addMustTermOrTerms(filter, ActiveRuleDocument.FIELD_INHERITANCE, newArrayList(inheritance));
+ }
return filter;
}
public long countProfileRules(ProfileRuleQuery query) {
- return index.executeCount(index.client().prepareCount(INDEX_RULES).setTypes(TYPE_ACTIVE_RULE)
- .setQuery(QueryBuilders.filteredQuery(QueryBuilders.matchAllQuery(), activeRuleFilter(query))));
+ return index.executeCount(
+ index.client()
+ .prepareCount(INDEX_RULES)
+ .setTypes(TYPE_ACTIVE_RULE)
+ .setQuery(QueryBuilders.filteredQuery(QueryBuilders.matchAllQuery(), activeRuleFilter(query)))
+ );
}
public long countInactiveProfileRules(ProfileRuleQuery query) {
# GET /profiles/inheritance?id=<profile id>
def inheritance
require_parameters 'id'
- @profile = Profile.find(params[:id])
- profiles=Profile.all(:conditions => ['language=? and id<>? and (parent_name is null or parent_name<>?)', @profile.language, @profile.id, @profile.name], :order => 'name')
- @select_parent = [[message('none'), nil]] + profiles.collect { |profile| [profile.name, profile.name] }
+ call_backend do
+ @profile = Internal.quality_profiles.profile(params[:id].to_i)
+ @ancestors = Internal.quality_profiles.ancestors(@profile).to_a
+ @children = Internal.quality_profiles.children(@profile).to_a
+ profiles = Internal.quality_profiles.profilesByLanguage(@profile.language()).to_a.reject{|p| p.id == @profile.id() || p.parent() == @profile.name()}
+ profiles = Api::Utils.insensitive_sort(profiles) { |p| p.name()}
+ @select_parent = [[message('none'), nil]] + profiles.collect { |profile| [profile.name(), profile.name()] }
+ end
set_profile_breadcrumbs
end
controller.java_facade.getLanguages()
end
- def label_for_rules_count(profile)
- label="#{profile.count_active_rules} #{message('rules').downcase}"
+ def label_for_rules_count(qProfile)
+ profile_rules_count = profile_rules_count(qProfile)
+ label = "#{profile_rules_count} #{message('rules').downcase}"
- count_overriding=profile.count_overriding_rules
+ count_overriding = Internal.quality_profiles.countOverridingProfileRules(qProfile).to_i
if count_overriding>0
label += message('quality_profiles.including_x_overriding.suffix', :params => count_overriding)
label += image_tag('overrides.png')
<tr>
<td align="center" valign="top">
<div>
- <% @profile.ancestors.reverse.each do |parent| %>
- <a href="<%= url_for :action => 'inheritance', :id => parent.id -%>"><%= parent.name -%></a>
+ <% @ancestors.reverse.each do |parent| %>
+ <a href="<%= url_for :action => 'inheritance', :id => parent.id() -%>"><%= parent.name() -%></a>
<span class="note">(<%= label_for_rules_count(parent) -%>)</span><br/>
<%= image_tag 'blue-up.png' -%><br/>
<% end %>
<b><%= @profile.name -%></b> <span class="note">(<%= label_for_rules_count(@profile) -%>)</span><br/>
- <% if @profile.children.size>0 %>
+ <% if @children.size>0 %>
<%= image_tag 'blue-up.png' -%><br/>
- <% @profile.children.each_with_index do |child,index| %>
+ <% @children.each_with_index do |child,index| %>
<%= ', ' if index>0 -%>
- <a href="<%= url_for :action => 'inheritance', :id => child.id -%>"><%= child.name -%></a>
+ <a href="<%= url_for :action => 'inheritance', :id => child.id() -%>"><%= child.name() -%></a>
<span class="note">(<%= label_for_rules_count(child) -%>)</span>
<% end %>
<br/><%= image_tag 'blue-up.png' -%><br/>
<h3><%= message('quality_profiles.set_parent') -%>:</h3>
<p><%= message('quality_profiles.inherit_rules_from_profile') -%>:</p>
<% form_tag({:action => 'change_parent'}, {:method => 'post'}) do %>
- <%= hidden_field_tag "id", @profile.id %>
- <%= select_tag "parent_name", options_for_select(@select_parent, @profile.parent_name) %>
+ <%= hidden_field_tag "id", @profile.id() %>
+ <%= select_tag "parent_name", options_for_select(@select_parent, @profile.parent()) %>
<%= submit_tag message('change_verb'), :id => 'submit_parent'%>
<% end %>
</div>
assertThat(qProfile.used()).isFalse();
}
+ @Test
+ public void search_profiles_by_language() throws Exception {
+ search.profiles("java");
+ verify(dao).selectByLanguage("java");
+ }
+
@Test
public void search_children_profiles() throws Exception {
search.children(new QProfile().setName("Sonar Way").setLanguage("java"));
assertThat(search.defaultProfile("java")).isNull();
}
-}
+ @Test
+ public void search_ancestors() throws Exception {
+ when(dao.selectParent(3)).thenReturn(new QualityProfileDto().setId(2).setName("Child").setLanguage("java").setParent("Parent"));
+ when(dao.selectParent(2)).thenReturn(new QualityProfileDto().setId(1).setName("Parent").setLanguage("java"));
+ when(dao.selectParent(1)).thenReturn(null);
+ List<QProfile> result = search.ancestors(new QProfile().setId(3).setName("Grandchild").setLanguage("java").setParent("Child"));
+ assertThat(result).hasSize(2);
+ }
+
+ @Test
+ public void fail_to_get_ancestors_if_parent_cannot_be_found() throws Exception {
+ when(dao.selectParent(3)).thenReturn(null);
+
+ try {
+ search.ancestors(new QProfile().setId(3).setName("Grandchild").setLanguage("java").setParent("Child"));
+ } catch (Exception e) {
+ assertThat(e).isInstanceOf(IllegalStateException.class);
+ }
+ }
+
+}
verify(search).allProfiles();
}
+ @Test
+ public void search_profiles_by_language() throws Exception {
+ qProfiles.profilesByLanguage("java");
+ verify(search).profiles("java");
+ }
+
@Test
public void search_default_profile_by_language() throws Exception {
qProfiles.defaultProfile("java");
verify(search).children(profile);
}
+ @Test
+ public void search_ancestors() throws Exception {
+ QProfile profile = new QProfile();
+ qProfiles.ancestors(profile);
+ verify(search).ancestors(profile);
+ }
+
@Test
public void count_children() throws Exception {
QProfile profile = new QProfile();
public class ProfileRuleQueryTest {
@Test
- public void should_create_basic_query() {
+ public void create_basic_query() {
final int profileId = 42;
ProfileRuleQuery query = ProfileRuleQuery.create(profileId);
assertThat(query.profileId()).isEqualTo(profileId);
}
@Test
- public void should_parse_nominal_request() {
+ public void parse_nominal_request() {
final int profileId = 42;
Map<String, Object> params = ImmutableMap.of("profileId", (Object) Integer.toString(profileId));
ProfileRuleQuery query = ProfileRuleQuery.parse(params);
}
@Test
- public void should_fail_on_missing_profileId() {
+ public void parse_with_inheritance() {
+ final int profileId = 42;
+ Map<String, Object> params = ImmutableMap.of(
+ "profileId", (Object) Integer.toString(profileId),
+ "inheritance", "OVERRIDES"
+ );
+ ProfileRuleQuery query = ProfileRuleQuery.parse(params);
+ assertThat(query.profileId()).isEqualTo(profileId);
+ assertThat(query.inheritance()).isEqualTo("OVERRIDES");
+ }
+
+ @Test
+ public void fail_on_missing_profileId() {
Map<String, Object> params = ImmutableMap.of();
try {
ProfileRuleQuery.parse(params);
}
@Test
- public void should_fail_on_incorrect_profileId() {
+ public void fail_on_incorrect_profileId() {
Map<String, Object> params = ImmutableMap.of("profileId", (Object) "not an integer");
try {
ProfileRuleQuery.parse(params);
assertThat(rulesWParam.get(0).params()).hasSize(2);
}
+ @Test
+ public void find_profile_rules_with_inheritance() {
+ Paging paging = Paging.create(10, 1);
+
+ assertThat(profileRules.searchProfileRules(ProfileRuleQuery.create(1).setInheritance(null), paging).rules()).hasSize(3);
+ assertThat(profileRules.searchProfileRules(ProfileRuleQuery.create(1).setInheritance(QProfileRule.INHERITED), paging).rules()).hasSize(1);
+ assertThat(profileRules.searchProfileRules(ProfileRuleQuery.create(1).setInheritance(QProfileRule.OVERRIDES), paging).rules()).hasSize(1);
+ }
+
@Test
@Ignore("bug in E/S : fail to do a scroll when filter contain has_parent -> return good total_hits but hits is empty")
public void find_profile_rule_ids() {
-{"id": 25, "severity": "MINOR", "profileId": 1, "inheritance": null}
+{"id": 25, "severity": "MINOR", "profileId": 1, "inheritance": "OVERRIDES"}
-{"id": 391, "severity": "MAJOR", "profileId": 1, "inheritance": null}
\ No newline at end of file
+{"id": 391, "severity": "MAJOR", "profileId": 1, "inheritance": "INHERITED"}
projects / sonarqube.git / commitdiff