Add errors to JSON output for files below minimum coverage

Report all four types of coverage threshold violations in the JSON
formatter's errors object: minimum_coverage, minimum_coverage_by_file,
minimum_coverage_by_group, and maximum_coverage_drop. Each violation
includes expected and actual values. This makes the JSON self-contained
for downstream consumers (e.g. CI reporters) that don't have access to
the Ruby process.

Co-Authored-By: Tejas <tejas.shetty@mailbox.org>

Author: sferik

lib/simplecov/formatter/json_formatter/result_hash_formatter.rb

@@ -14,6 +14,7 @@ def format
           format_total
           format_files
           format_groups
+          format_errors
 
           formatted_result
         end
@@ -37,14 +38,92 @@ def format_groups
           end
         end
 
+        def format_errors
+          format_minimum_coverage_errors
+          format_minimum_coverage_by_file_errors
+          format_minimum_coverage_by_group_errors
+          format_maximum_coverage_drop_errors
+        end
+
+        CRITERION_KEYS = {line: :lines, branch: :branches, method: :methods}.freeze
+        private_constant :CRITERION_KEYS
+
+        def format_minimum_coverage_errors
+          SimpleCov.minimum_coverage.each do |criterion, expected_percent|
+            actual = @result.coverage_statistics.fetch(criterion).percent
+            next unless actual < expected_percent
+
+            key = CRITERION_KEYS.fetch(criterion)
+            minimum_coverage = formatted_result[:errors][:minimum_coverage] ||= {}
+            minimum_coverage[key] = {expected: expected_percent, actual: actual}
+          end
+        end
+
+        def format_minimum_coverage_by_file_errors
+          SimpleCov.minimum_coverage_by_file.each do |criterion, expected_percent|
+            @result.files.each do |file|
+              actual = SimpleCov.round_coverage(file.coverage_statistics.fetch(criterion).percent)
+              next unless actual < expected_percent
+
+              key = CRITERION_KEYS.fetch(criterion)
+              by_file = formatted_result[:errors][:minimum_coverage_by_file] ||= {}
+              criterion_errors = by_file[key] ||= {}
+              criterion_errors[file.filename] = {expected: expected_percent, actual: actual}
+            end
+          end
+        end
+
+        def format_minimum_coverage_by_group_errors
+          SimpleCov.minimum_coverage_by_group.each do |group_name, minimum_group_coverage|
+            group = @result.groups[group_name]
+            next unless group
+
+            minimum_group_coverage.each do |criterion, expected_percent|
+              actual = SimpleCov.round_coverage(group.coverage_statistics.fetch(criterion).percent)
+              next unless actual < expected_percent
+
+              key = CRITERION_KEYS.fetch(criterion)
+              by_group = formatted_result[:errors][:minimum_coverage_by_group] ||= {}
+              group_errors = by_group[group_name] ||= {}
+              group_errors[key] = {expected: expected_percent, actual: actual}
+            end
+          end
+        end
+
+        def format_maximum_coverage_drop_errors
+          return if SimpleCov.maximum_coverage_drop.empty?
+
+          last_run = SimpleCov::LastRun.read
+          return unless last_run
+
+          SimpleCov.maximum_coverage_drop.each do |criterion, max_drop|
+            drop = coverage_drop_for(criterion, last_run)
+            next unless drop && drop > max_drop
+
+            key = CRITERION_KEYS.fetch(criterion)
+            coverage_drop = formatted_result[:errors][:maximum_coverage_drop] ||= {}
+            coverage_drop[key] = {maximum: max_drop, actual: drop}
+          end
+        end
+
+        def coverage_drop_for(criterion, last_run)
+          last_coverage_percent = last_run.dig(:result, criterion)
+          last_coverage_percent ||= last_run.dig(:result, :covered_percent) if criterion == :line
+          return nil unless last_coverage_percent
+
+          current = SimpleCov.round_coverage(@result.coverage_statistics.fetch(criterion).percent)
+          (last_coverage_percent - current).floor(10)
+        end
+
         def formatted_result
           @formatted_result ||= {
             meta: {
               simplecov_version: SimpleCov::VERSION
             },
             total: {},
             coverage: {},
-            groups: {}
+            groups: {},
+            errors: {}
           }
         end
 

spec/fixtures/json/sample.json

@@ -43,5 +43,6 @@
       "lines_covered_percent": 90.0
     }
   },
-  "groups": {}
+  "groups": {},
+  "errors": {}
 }

spec/fixtures/json/sample_groups.json

@@ -53,5 +53,6 @@
         "strength": 0.0
       }
     }
-  }
+  },
+  "errors": {}
 }

spec/fixtures/json/sample_with_branch.json

@@ -65,5 +65,6 @@
       "branches_covered_percent": 50.0
     }
   },
-  "groups": {}
+  "groups": {},
+  "errors": {}
 }

spec/fixtures/json/sample_with_method.json

@@ -77,5 +77,6 @@
       "methods_covered_percent": 100.0
     }
   },
-  "groups": {}
+  "groups": {},
+  "errors": {}
 }

spec/json_formatter_spec.rb

@@ -107,6 +107,163 @@
       end
     end
 
+    context "with minimum_coverage below threshold" do
+      before do
+        allow(SimpleCov).to receive(:minimum_coverage).and_return(line: 95)
+      end
+
+      it "reports the violation in errors" do
+        subject.format(result)
+        errors = json_output.fetch("errors")
+        expect(errors).to eq(
+          "minimum_coverage" => {"lines" => {"expected" => 95, "actual" => 90.0}}
+        )
+      end
+    end
+
+    context "with minimum_coverage above threshold" do
+      before do
+        allow(SimpleCov).to receive(:minimum_coverage).and_return(line: 80)
+      end
+
+      it "returns empty errors" do
+        subject.format(result)
+        expect(json_output.fetch("errors")).to eq({})
+      end
+    end
+
+    context "with minimum_coverage_by_file for lines" do
+      before do
+        allow(SimpleCov).to receive(:minimum_coverage_by_file).and_return(line: 95)
+      end
+
+      it "reports files below the threshold in errors" do
+        subject.format(result)
+        errors = json_output.fetch("errors")
+        expect(errors).to eq(
+          "minimum_coverage_by_file" => {
+            "lines" => {source_fixture("json/sample.rb") => {"expected" => 95, "actual" => 90.0}}
+          }
+        )
+      end
+    end
+
+    context "with minimum_coverage_by_file for branches" do
+      let(:result) do
+        SimpleCov::Result.new({
+                                source_fixture("json/sample.rb") => {
+                                  "lines" => [nil, 1, 1, 1, 1, nil, nil, 1, 1, nil, nil,
+                                              1, 1, 0, nil, 1, nil, nil, nil, nil, 1, 0, nil, nil, nil],
+                                  "branches" => {
+                                    [:if, 0, 13, 4, 17, 7] => {
+                                      [:then, 1, 14, 6, 14, 10] => 0,
+                                      [:else, 2, 16, 6, 16, 10] => 1
+                                    }
+                                  }
+                                }
+                              })
+      end
+
+      before do
+        enable_branch_coverage
+        allow(SimpleCov).to receive(:minimum_coverage_by_file).and_return(branch: 75)
+      end
+
+      it "reports files below the threshold in errors" do
+        subject.format(result)
+        errors = json_output.fetch("errors")
+        expect(errors).to eq(
+          "minimum_coverage_by_file" => {
+            "branches" => {source_fixture("json/sample.rb") => {"expected" => 75, "actual" => 50.0}}
+          }
+        )
+      end
+    end
+
+    context "with minimum_coverage_by_file when all files pass" do
+      before do
+        allow(SimpleCov).to receive(:minimum_coverage_by_file).and_return(line: 80)
+      end
+
+      it "returns empty errors" do
+        subject.format(result)
+        expect(json_output.fetch("errors")).to eq({})
+      end
+    end
+
+    context "with minimum_coverage_by_group below threshold" do
+      let(:line_stats) { SimpleCov::CoverageStatistics.new(covered: 7, missed: 3) }
+
+      let(:result) do
+        res = SimpleCov::Result.new({
+                                      source_fixture("json/sample.rb") => {"lines" => [
+                                        nil, 1, 1, 1, 1, nil, nil, 1, 1, nil, nil,
+                                        1, 1, 0, nil, 1, nil, nil, nil, nil, 1, 0, nil, nil, nil
+                                      ]}
+                                    })
+
+        allow(res).to receive_messages(
+          groups: {"Models" => double("File List", coverage_statistics: {line: line_stats})}
+        )
+        res
+      end
+
+      before do
+        allow(SimpleCov).to receive(:minimum_coverage_by_group).and_return("Models" => {line: 80})
+      end
+
+      it "reports the group violation in errors" do
+        subject.format(result)
+        errors = json_output.fetch("errors")
+        expect(errors).to eq(
+          "minimum_coverage_by_group" => {
+            "Models" => {"lines" => {"expected" => 80, "actual" => 70.0}}
+          }
+        )
+      end
+    end
+
+    context "with maximum_coverage_drop exceeded" do
+      before do
+        allow(SimpleCov).to receive(:maximum_coverage_drop).and_return(line: 2)
+        allow(SimpleCov::LastRun).to receive(:read).and_return({result: {line: 95.0}})
+      end
+
+      it "reports the drop in errors" do
+        subject.format(result)
+        errors = json_output.fetch("errors")
+        expect(errors).to eq(
+          "maximum_coverage_drop" => {
+            "lines" => {"maximum" => 2, "actual" => 5.0}
+          }
+        )
+      end
+    end
+
+    context "with maximum_coverage_drop not exceeded" do
+      before do
+        allow(SimpleCov).to receive(:maximum_coverage_drop).and_return(line: 2)
+        allow(SimpleCov::LastRun).to receive(:read).and_return({result: {line: 91.0}})
+      end
+
+      it "returns empty errors" do
+        subject.format(result)
+        expect(json_output.fetch("errors")).to eq({})
+      end
+    end
+
+    context "with maximum_coverage_drop and no last run" do
+      before do
+        allow(SimpleCov).to receive(:maximum_coverage_drop).and_return(line: 2)
+        allow(SimpleCov::LastRun).to receive(:read).and_return(nil)
+      end
+
+      it "returns empty errors" do
+        subject.format(result)
+        expect(json_output.fetch("errors")).to eq({})
+      end
+    end
+
     context "with groups" do
       let(:line_stats) { SimpleCov::CoverageStatistics.new(covered: 8, missed: 2) }