SONAR-6044 Stop storing distribution of issue-related measures by rule

3 files changed, 46 insertions, 165 deletions

diff --git a/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/CountUnresolvedIssuesDecorator.java b/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/CountUnresolvedIssuesDecorator.java
index d775ba8ec4c..1b2758732f9 100644
--- a/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/CountUnresolvedIssuesDecorator.java
+++ b/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/CountUnresolvedIssuesDecorator.java
@@ -30,14 +30,16 @@ import org.sonar.api.measures.*;
 import org.sonar.api.resources.Project;
 import org.sonar.api.resources.Resource;
 import org.sonar.api.resources.ResourceUtils;
-import org.sonar.api.rule.RuleKey;
-import org.sonar.api.rules.RulePriority;
+import org.sonar.api.rule.Severity;
 import org.sonar.batch.components.Period;
 import org.sonar.batch.components.TimeMachineConfiguration;
 
 import javax.annotation.Nullable;
 
-import java.util.*;
+import java.util.Calendar;
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
 
 /**
  * Computes metrics related to number of issues.
@@ -88,18 +90,15 @@ public class CountUnresolvedIssuesDecorator implements Decorator {
       Collection<Issue> issues = issuable.issues();
       boolean shouldSaveNewMetrics = shouldSaveNewMetrics(context);
 
-      Multiset<RulePriority> severityBag = HashMultiset.create();
-      Map<RulePriority, Multiset<RuleKey>> rulesPerSeverity = Maps.newHashMap();
-      ListMultimap<RulePriority, Issue> issuesPerSeverity = ArrayListMultimap.create();
+      Multiset<String> severityBag = HashMultiset.create();
+      ListMultimap<String, Issue> issuesPerSeverity = ArrayListMultimap.create();
       int countOpen = 0;
       int countReopened = 0;
       int countConfirmed = 0;
 
       for (Issue issue : issues) {
-        severityBag.add(RulePriority.valueOf(issue.severity()));
-        Multiset<RuleKey> rulesBag = initRules(rulesPerSeverity, RulePriority.valueOf(issue.severity()));
-        rulesBag.add(issue.ruleKey());
-        issuesPerSeverity.put(RulePriority.valueOf(issue.severity()), issue);
+        severityBag.add(issue.severity());
+        issuesPerSeverity.put(issue.severity(), issue);
 
         if (Issue.STATUS_OPEN.equals(issue.status())) {
           countOpen++;
@@ -110,11 +109,9 @@ public class CountUnresolvedIssuesDecorator implements Decorator {
         }
       }
 
-      for (RulePriority ruleSeverity : RulePriority.values()) {
-        saveIssuesForSeverity(context, ruleSeverity, severityBag);
-        saveIssuesPerRules(context, ruleSeverity, rulesPerSeverity);
-        saveNewIssuesForSeverity(context, ruleSeverity, issuesPerSeverity, shouldSaveNewMetrics);
-        saveNewIssuesPerRule(context, ruleSeverity, issues, shouldSaveNewMetrics);
+      for (String severity : Severity.ALL) {
+        saveIssuesForSeverity(context, severity, severityBag);
+        saveNewIssuesForSeverity(context, severity, issuesPerSeverity, shouldSaveNewMetrics);
       }
 
       saveTotalIssues(context, issues);
@@ -141,16 +138,16 @@ public class CountUnresolvedIssuesDecorator implements Decorator {
     }
   }
 
-  private void saveIssuesForSeverity(DecoratorContext context, RulePriority ruleSeverity, Multiset<RulePriority> severitiesBag) {
-    Metric metric = SeverityUtils.severityToIssueMetric(ruleSeverity);
+  private void saveIssuesForSeverity(DecoratorContext context, String severity, Multiset<String> severitiesBag) {
+    Metric metric = SeverityUtils.severityToIssueMetric(severity);
     if (context.getMeasure(metric) == null) {
       Collection<Measure> children = context.getChildrenMeasures(MeasuresFilters.metric(metric));
-      int sum = MeasureUtils.sum(true, children).intValue() + severitiesBag.count(ruleSeverity);
+      int sum = MeasureUtils.sum(true, children).intValue() + severitiesBag.count(severity);
       context.saveMeasure(metric, (double) sum);
     }
   }
 
-  private void saveNewIssuesForSeverity(DecoratorContext context, RulePriority severity, ListMultimap<RulePriority, Issue> issuesPerSeverities, boolean shouldSaveNewMetrics) {
+  private void saveNewIssuesForSeverity(DecoratorContext context, String severity, ListMultimap<String, Issue> issuesPerSeverities, boolean shouldSaveNewMetrics) {
     if (shouldSaveNewMetrics) {
       Metric metric = SeverityUtils.severityToNewMetricIssue(severity);
       Measure measure = new Measure(metric);
@@ -158,66 +155,6 @@ public class CountUnresolvedIssuesDecorator implements Decorator {
     }
   }
 
-  private void saveIssuesPerRules(DecoratorContext context, RulePriority severity, Map<RulePriority, Multiset<RuleKey>> rulesPerSeverity) {
-    Metric metric = SeverityUtils.severityToIssueMetric(severity);
-
-    Collection<Measure> children = context.getChildrenMeasures(MeasuresFilters.rules(metric));
-    for (Measure child : children) {
-      RuleMeasure childRuleMeasure = (RuleMeasure) child;
-      RuleKey ruleKey = childRuleMeasure.ruleKey();
-      if (ruleKey != null && MeasureUtils.hasValue(childRuleMeasure)) {
-        Multiset<RuleKey> rulesBag = initRules(rulesPerSeverity, severity);
-        rulesBag.add(ruleKey, childRuleMeasure.getIntValue());
-      }
-    }
-
-    Multiset<RuleKey> rulesBag = rulesPerSeverity.get(severity);
-    if (rulesBag != null) {
-      for (Multiset.Entry<RuleKey> entry : rulesBag.entrySet()) {
-        RuleMeasure measure = RuleMeasure.createForRule(metric, entry.getElement(), (double) entry.getCount());
-        measure.setSeverity(severity);
-        context.saveMeasure(measure);
-      }
-    }
-  }
-
-  private void saveNewIssuesPerRule(DecoratorContext context, RulePriority severity, Collection<Issue> issues, boolean shouldSaveNewMetrics) {
-    if (shouldSaveNewMetrics) {
-      Metric metric = SeverityUtils.severityToNewMetricIssue(severity);
-      ListMultimap<RuleKey, Measure> childMeasuresPerRuleKeys = ArrayListMultimap.create();
-      ListMultimap<RuleKey, Issue> issuesPerRuleKeys = ArrayListMultimap.create();
-      Set<RuleKey> ruleKeys = Sets.newHashSet();
-
-      Collection<Measure> children = context.getChildrenMeasures(MeasuresFilters.rules(metric));
-      for (Measure child : children) {
-        RuleMeasure childRuleMeasure = (RuleMeasure) child;
-        RuleKey ruleKey = childRuleMeasure.ruleKey();
-        if (ruleKey != null) {
-          childMeasuresPerRuleKeys.put(ruleKey, childRuleMeasure);
-          ruleKeys.add(ruleKey);
-        }
-      }
-
-      for (Issue issue : issues) {
-        if (RulePriority.valueOf(issue.severity()).equals(severity)) {
-          ruleKeys.add(issue.ruleKey());
-          issuesPerRuleKeys.put(issue.ruleKey(), issue);
-        }
-      }
-
-      for (RuleKey ruleKey : ruleKeys) {
-        RuleMeasure measure = RuleMeasure.createForRule(metric, ruleKey, null);
-        measure.setSeverity(severity);
-        for (Period period : timeMachineConfiguration.periods()) {
-          int variationIndex = period.getIndex();
-          double sum = MeasureUtils.sumOnVariation(true, variationIndex, childMeasuresPerRuleKeys.get(ruleKey)) + countIssues(issuesPerRuleKeys.get(ruleKey), period);
-          measure.setVariation(variationIndex, sum);
-        }
-        context.saveMeasure(measure);
-      }
-    }
-  }
-
   private void saveNewIssues(DecoratorContext context, Measure measure, Collection<Issue> issues) {
     for (Period period : timeMachineConfiguration.periods()) {
       int variationIndex = period.getIndex();
@@ -240,15 +177,6 @@ public class CountUnresolvedIssuesDecorator implements Decorator {
     return sum;
   }
 
-  private Multiset<RuleKey> initRules(Map<RulePriority, Multiset<RuleKey>> rulesPerSeverity, RulePriority severity) {
-    Multiset<RuleKey> rulesBag = rulesPerSeverity.get(severity);
-    if (rulesBag == null) {
-      rulesBag = HashMultiset.create();
-      rulesPerSeverity.put(severity, rulesBag);
-    }
-    return rulesBag;
-  }
-
   private int countIssues(Collection<Issue> issues, Period period) {
     // SONAR-3647 Use real snapshot date and not target date in order to stay consistent with other measure variations
     Date datePlusOneSecond = period.getDate() != null ? DateUtils.addSeconds(period.getDate(), 1) : null;
@@ -257,9 +185,6 @@ public class CountUnresolvedIssuesDecorator implements Decorator {
 
   @VisibleForTesting
   int countIssuesAfterDate(Collection<Issue> issues, @Nullable Date date) {
-    if (issues == null) {
-      return 0;
-    }
     int count = 0;
     for (Issue issue : issues) {
       if (isAfter(issue, date)) {
diff --git a/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/SeverityUtils.java b/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/SeverityUtils.java
index e1a1d5ba19c..ed6b9551e16 100644
--- a/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/SeverityUtils.java
+++ b/plugins/sonar-core-plugin/src/main/java/org/sonar/plugins/core/issue/SeverityUtils.java
@@ -21,46 +21,44 @@ package org.sonar.plugins.core.issue;
 
 import org.sonar.api.measures.CoreMetrics;
 import org.sonar.api.measures.Metric;
-import org.sonar.api.rules.RulePriority;
+import org.sonar.api.rule.Severity;
 
 final class SeverityUtils {
   private SeverityUtils() {
     // only static methods
   }
 
-  static Metric severityToIssueMetric(RulePriority severity) {
-    Metric metric;
-    if (severity.equals(RulePriority.BLOCKER)) {
-      metric = CoreMetrics.BLOCKER_VIOLATIONS;
-    } else if (severity.equals(RulePriority.CRITICAL)) {
-      metric = CoreMetrics.CRITICAL_VIOLATIONS;
-    } else if (severity.equals(RulePriority.MAJOR)) {
-      metric = CoreMetrics.MAJOR_VIOLATIONS;
-    } else if (severity.equals(RulePriority.MINOR)) {
-      metric = CoreMetrics.MINOR_VIOLATIONS;
-    } else if (severity.equals(RulePriority.INFO)) {
-      metric = CoreMetrics.INFO_VIOLATIONS;
-    } else {
-      throw new IllegalArgumentException("Unsupported severity: " + severity);
+  static Metric severityToIssueMetric(String severity) {
+    switch (severity) {
+      case Severity.BLOCKER:
+        return CoreMetrics.BLOCKER_VIOLATIONS;
+      case Severity.CRITICAL:
+        return CoreMetrics.CRITICAL_VIOLATIONS;
+      case Severity.MAJOR:
+        return CoreMetrics.MAJOR_VIOLATIONS;
+      case Severity.MINOR:
+        return CoreMetrics.MINOR_VIOLATIONS;
+      case Severity.INFO:
+        return CoreMetrics.INFO_VIOLATIONS;
+      default:
+        throw new IllegalArgumentException("Unsupported severity: " + severity);
     }
-    return metric;
   }
 
-  static Metric severityToNewMetricIssue(RulePriority severity) {
-    Metric metric;
-    if (severity.equals(RulePriority.BLOCKER)) {
-      metric = CoreMetrics.NEW_BLOCKER_VIOLATIONS;
-    } else if (severity.equals(RulePriority.CRITICAL)) {
-      metric = CoreMetrics.NEW_CRITICAL_VIOLATIONS;
-    } else if (severity.equals(RulePriority.MAJOR)) {
-      metric = CoreMetrics.NEW_MAJOR_VIOLATIONS;
-    } else if (severity.equals(RulePriority.MINOR)) {
-      metric = CoreMetrics.NEW_MINOR_VIOLATIONS;
-    } else if (severity.equals(RulePriority.INFO)) {
-      metric = CoreMetrics.NEW_INFO_VIOLATIONS;
-    } else {
-      throw new IllegalArgumentException("Unsupported severity: " + severity);
+  static Metric severityToNewMetricIssue(String severity) {
+    switch (severity) {
+      case Severity.BLOCKER:
+        return CoreMetrics.NEW_BLOCKER_VIOLATIONS;
+      case Severity.CRITICAL:
+        return CoreMetrics.NEW_CRITICAL_VIOLATIONS;
+      case Severity.MAJOR:
+        return CoreMetrics.NEW_MAJOR_VIOLATIONS;
+      case Severity.MINOR:
+        return CoreMetrics.NEW_MINOR_VIOLATIONS;
+      case Severity.INFO:
+        return CoreMetrics.NEW_INFO_VIOLATIONS;
+      default:
+        throw new IllegalArgumentException("Unsupported severity: " + severity);
     }
-    return metric;
   }
 }
diff --git a/plugins/sonar-core-plugin/src/test/java/org/sonar/plugins/core/issue/CountUnresolvedIssuesDecoratorTest.java b/plugins/sonar-core-plugin/src/test/java/org/sonar/plugins/core/issue/CountUnresolvedIssuesDecoratorTest.java
index be9b8ae586c..054f2b5f02f 100644
--- a/plugins/sonar-core-plugin/src/test/java/org/sonar/plugins/core/issue/CountUnresolvedIssuesDecoratorTest.java
+++ b/plugins/sonar-core-plugin/src/test/java/org/sonar/plugins/core/issue/CountUnresolvedIssuesDecoratorTest.java
@@ -39,7 +39,6 @@ import org.sonar.api.rule.RuleKey;
 import org.sonar.api.rule.Severity;
 import org.sonar.api.rules.Rule;
 import org.sonar.api.rules.RulePriority;
-import org.sonar.api.test.IsRuleMeasure;
 import org.sonar.batch.components.Period;
 import org.sonar.batch.components.TimeMachineConfiguration;
 
@@ -186,39 +185,10 @@ public class CountUnresolvedIssuesDecoratorTest {
   }
 
   @Test
-  public void should_count_issues_per_rule() {
-    List<Issue> issues = newArrayList();
-    issues.add(new DefaultIssue().setRuleKey(ruleA1.ruleKey()).setSeverity(RulePriority.CRITICAL.name()));
-    issues.add(new DefaultIssue().setRuleKey(ruleA1.ruleKey()).setSeverity(RulePriority.CRITICAL.name()));
-    issues.add(new DefaultIssue().setRuleKey(ruleA2.ruleKey()).setSeverity(RulePriority.MAJOR.name()));
-    when(issuable.issues()).thenReturn(issues);
-
-    decorator.decorate(resource, context);
-
-    verify(context).saveMeasure(argThat(new IsRuleMeasure(CoreMetrics.CRITICAL_VIOLATIONS, ruleA1, 2.0)));
-    verify(context, never()).saveMeasure(argThat(new IsRuleMeasure(CoreMetrics.MAJOR_VIOLATIONS, ruleA1, 0.0)));
-    verify(context).saveMeasure(argThat(new IsRuleMeasure(CoreMetrics.MAJOR_VIOLATIONS, ruleA2, 1.0)));
-  }
-
-  @Test
-  public void same_rule_should_have_different_severities() {
-    List<Issue> issues = newArrayList();
-    issues.add(new DefaultIssue().setRuleKey(ruleA1.ruleKey()).setSeverity(RulePriority.CRITICAL.name()));
-    issues.add(new DefaultIssue().setRuleKey(ruleA1.ruleKey()).setSeverity(RulePriority.CRITICAL.name()));
-    issues.add(new DefaultIssue().setRuleKey(ruleA1.ruleKey()).setSeverity(RulePriority.MINOR.name()));
-    when(issuable.issues()).thenReturn(issues);
-
-    decorator.decorate(resource, context);
-
-    verify(context).saveMeasure(argThat(new IsRuleMeasure(CoreMetrics.CRITICAL_VIOLATIONS, ruleA1, 2.0)));
-    verify(context).saveMeasure(argThat(new IsRuleMeasure(CoreMetrics.MINOR_VIOLATIONS, ruleA1, 1.0)));
-  }
-
-  @Test
   public void should_count_issues_after_date() {
     List<Issue> issues = createIssuesForNewMetrics();
 
-    assertThat(decorator.countIssuesAfterDate(null, fiveDaysAgo)).isEqualTo(0);
+    assertThat(decorator.countIssuesAfterDate(Collections.<Issue>emptyList(), fiveDaysAgo)).isEqualTo(0);
     assertThat(decorator.countIssuesAfterDate(issues, fiveDaysAgo)).isEqualTo(1); // 1 rightNow
     assertThat(decorator.countIssuesAfterDate(issues, tenDaysAgo)).isEqualTo(3); // 1 rightNow + 2 fiveDaysAgo
     assertThat(decorator.countIssuesAfterDate(issues, sameSecond)).isEqualTo(0); // 0
@@ -252,18 +222,6 @@ public class CountUnresolvedIssuesDecoratorTest {
   }
 
   @Test
-  public void should_save_rule_new_issues() {
-    when(issuable.issues()).thenReturn(createIssuesForNewMetrics());
-
-    decorator.decorate(resource, context);
-
-    // remember : period1 is 5daysAgo, period2 is 10daysAgo
-    verify(context).saveMeasure(argThat(new IsVariationRuleMeasure(CoreMetrics.NEW_CRITICAL_VIOLATIONS, ruleA1, 1.0, 1.0)));
-    verify(context).saveMeasure(argThat(new IsVariationRuleMeasure(CoreMetrics.NEW_MAJOR_VIOLATIONS, ruleA2, 0.0, 1.0)));
-    verify(context).saveMeasure(argThat(new IsVariationRuleMeasure(CoreMetrics.NEW_MINOR_VIOLATIONS, ruleB1, 0.0, 1.0)));
-  }
-
-  @Test
   public void should_not_save_new_issues_if_measure_already_computed() {
     when(context.getMeasure(CoreMetrics.NEW_VIOLATIONS)).thenReturn(new Measure());
     when(issuable.issues()).thenReturn(createIssuesForNewMetrics());