#731 Added option to break build when maximum risk hotspots metrics are exceeded

Author: danielpalme

src/Readme.txt

@@ -67,6 +67,10 @@ For further details take a look at LICENSE.txt.
 
 CHANGELOG
 
+5.4.7.0
+
+    * New: #731 Added option to break build when maximum risk hotspots metrics are exceeded
+
 5.4.6.0
 
     * Fix: #730 Added support for the REPORTGENERATOR_LICENSE environment variable in the MSBuild task (contributed by @0xced)

src/ReportGenerator.Core/CodeAnalysis/RiskHotspotsAnalysisThresholds.cs

@@ -19,5 +19,20 @@ public class RiskHotspotsAnalysisThresholds
         /// Gets or sets the threshold for NPath complexity.
         /// </summary>
         public decimal MetricThresholdForNPathComplexity { get; set; } = 200;
+
+        /// <summary>
+        /// Gets or sets the maximum threshold for cylomatic complexity. If any risk hotspot is greater this this treshold, ReportGenerator will exit unsuccessfully.
+        /// </summary>
+        public decimal? MaximumThresholdForCyclomaticComplexity { get; set; }
+
+        /// <summary>
+        /// Gets or sets the maximum threshold for crap score. If any risk hotspot is greater this this treshold, ReportGenerator will exit unsuccessfully.
+        /// </summary>
+        public decimal? MaximumThresholdForCrapScore { get; set; }
+
+        /// <summary>
+        /// Gets or sets the maximum threshold for NPath complexity. If any risk hotspot is greater this this treshold, ReportGenerator will exit unsuccessfully.
+        /// </summary>
+        public decimal? MaximumThresholdForNPathComplexity { get; set; }
     }
 }

src/ReportGenerator.Core/Generator.cs

@@ -59,6 +59,11 @@ public bool GenerateReport(IReportConfiguration reportConfiguration)
                 Logger.Error(ex.GetExceptionMessageForDisplay());
                 return false;
             }
+            catch (RiskhotspotThresholdException ex)
+            {
+                Logger.Error(ex.GetExceptionMessageForDisplay());
+                return false;
+            }
             catch (Exception ex)
             {
                 Logger.Error(ex.GetExceptionMessageForDisplay());
@@ -340,6 +345,9 @@ public void GenerateReport(
 
             new MinimumCoverageThresholdsValidator(minimumCoverageThresholds)
                 .Validate(parserResult);
+
+            new MaxiumRiskhotspotsThresholdsValidator(riskHotspotsAnalysisThresholds)
+                .Validate(reportContext.RiskHotspotAnalysisResult);
         }
 
         /// <summary>

src/ReportGenerator.Core/MaxiumRiskhotspotsThresholdsValidator.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using Palmmedia.ReportGenerator.Core.CodeAnalysis;
+using Palmmedia.ReportGenerator.Core.Properties;
+
+namespace Palmmedia.ReportGenerator.Core
+{
+    /// <summary>
+    /// Validates the risk hotspots thresholds.
+    /// </summary>
+    public class MaxiumRiskhotspotsThresholdsValidator
+    {
+        /// <summary>
+        /// The minimum coverage thresholds.
+        /// </summary>
+        private readonly RiskHotspotsAnalysisThresholds riskHotspotsAnalysisThresholds;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MaxiumRiskhotspotsThresholdsValidator" /> class.
+        /// </summary>
+        /// <param name="riskHotspotsAnalysisThresholds">The maximum risk hotspots thresholds.</param>
+        public MaxiumRiskhotspotsThresholdsValidator(RiskHotspotsAnalysisThresholds riskHotspotsAnalysisThresholds)
+        {
+            if (riskHotspotsAnalysisThresholds == null)
+            {
+                throw new ArgumentNullException(nameof(riskHotspotsAnalysisThresholds));
+            }
+
+            this.riskHotspotsAnalysisThresholds = riskHotspotsAnalysisThresholds;
+        }
+
+        /// <summary>
+        /// Validates the risk hotspots thresholds.
+        /// </summary>
+        /// <param name="riskHotspotAnalysisResult">The risk hotspots analysis.</param>
+        public void Validate(RiskHotspotAnalysisResult riskHotspotAnalysisResult)
+        {
+            var thresholdsByMetricName = new Dictionary<string, decimal>();
+
+            if (this.riskHotspotsAnalysisThresholds.MaximumThresholdForCyclomaticComplexity.HasValue)
+            {
+                thresholdsByMetricName.Add(ReportResources.CyclomaticComplexity, this.riskHotspotsAnalysisThresholds.MaximumThresholdForCyclomaticComplexity.Value);
+            }
+
+            if (this.riskHotspotsAnalysisThresholds.MaximumThresholdForCrapScore.HasValue)
+            {
+                thresholdsByMetricName.Add(ReportResources.CrapScore, this.riskHotspotsAnalysisThresholds.MaximumThresholdForCrapScore.Value);
+            }
+
+            if (this.riskHotspotsAnalysisThresholds.MaximumThresholdForNPathComplexity.HasValue)
+            {
+                thresholdsByMetricName.Add(ReportResources.NPathComplexity, this.riskHotspotsAnalysisThresholds.MaximumThresholdForNPathComplexity.Value);
+            }
+
+            if (thresholdsByMetricName.Count == 0)
+            {
+                return;
+            }
+
+            var errors = new List<string>();
+
+            foreach (var riskHotspot in riskHotspotAnalysisResult.RiskHotspots)
+            {
+                foreach (var statusMetric in riskHotspot.StatusMetrics)
+                {
+                    if (!thresholdsByMetricName.TryGetValue(statusMetric.Metric.Name, out var threshold))
+                    {
+                        continue;
+                    }
+
+                    if (statusMetric.Metric.Value > threshold)
+                    {
+                        errors.Add(string.Format(
+                            Resources.ErrorRiskHotspot,
+                            statusMetric.Metric.Value,
+                            riskHotspot.Assembly.Name,
+                            riskHotspot.Class.Name,
+                            riskHotspot.MethodMetric.FullName,
+                            statusMetric.Metric.Name,
+                            threshold));
+                    }
+                }
+            }
+
+            if (errors.Count > 0)
+            {
+                throw new RiskhotspotThresholdException(string.Join("\r\n", errors));
+            }
+        }
+    }
+}

src/ReportGenerator.Core/MinimumCoverageThresholdsValidator.cs

@@ -38,7 +38,8 @@ public void Validate(ParserResult parserResult)
         {
             if (!this.minimumCoverageThresholds.LineCoverage.HasValue
                 && !this.minimumCoverageThresholds.BranchCoverage.HasValue
-                && !this.minimumCoverageThresholds.MethodCoverage.HasValue)
+                && !this.minimumCoverageThresholds.MethodCoverage.HasValue
+                && !this.minimumCoverageThresholds.FullMethodCoverage.HasValue)
             {
                 return;
             }

src/ReportGenerator.Core/Properties/Resources.Designer.cs

@@ -346,4 +346,7 @@
   <data name="ErrorLowFullMethodCoverage" xml:space="preserve">
     <value>The full method coverage of {0}% is below the minimum threshold of {1}%.</value>
   </data>
+  <data name="ErrorRiskHotspot" xml:space="preserve">
+    <value>The risk hotspot value {0} for assembly '{1}' class '{2}' method '{3}' metric '{4}' is greater than the maximum threshold of {5}.</value>
+  </data>
 </root>

src/ReportGenerator.Core/Properties/Resources.resx

@@ -0,0 +1,37 @@
+using System;
+
+namespace Palmmedia.ReportGenerator.Core
+{
+    /// <summary>
+    /// Exception indicating that mimimum coverage goals are not satisfied.
+    /// </summary>
+    [Serializable]
+    internal class RiskhotspotThresholdException : Exception
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RiskhotspotThresholdException"/> class.
+        /// </summary>
+        public RiskhotspotThresholdException()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RiskhotspotThresholdException"/> class.
+        /// </summary>
+        /// <param name="message">The message.</param>
+        public RiskhotspotThresholdException(string message)
+            : base(message)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RiskhotspotThresholdException"/> class.
+        /// </summary>
+        /// <param name="message">The message.</param>
+        /// <param name="inner">The inner exception.</param>
+        public RiskhotspotThresholdException(string message, Exception inner)
+            : base(message, inner)
+        {
+        }
+    }
+}

src/ReportGenerator.Core/RiskhotspotThresholdException.cs

@@ -2,7 +2,10 @@
   "riskHotspotsAnalysisThresholds": {
     "metricThresholdForCyclomaticComplexity": 15,
     "metricThresholdForCrapScore": 30,
-    "metricThresholdForNPathComplexity": 200
+    "metricThresholdForNPathComplexity": 200,
+    "maximumThresholdForCyclomaticComplexity": null,
+    "maximumThresholdForCrapScore": null,
+    "maximumThresholdForNPathComplexity": null
   },
   "minimumCoverageThresholds": {
     "lineCoverage": null,