Dogfood: run SimpleCov against its own spec suite

Bootstrap Coverage in spec/helper.rb before requiring simplecov, then
drive the formatter ourselves in an after(:suite) hook. Threshold
defaults to 100% and the build exits MINIMUM_COVERAGE when under;
SIMPLECOV_NO_DOGFOOD=1 skips the bootstrap.

Two follow-ups it surfaced: HTMLFormatter#format and JSONFormatter#format
now mkdir_p their output_dir, and simplecov_spec stubs Coverage.running?
to false in the start_coverage_measurement examples (Coverage is already
running under the dogfood bootstrap).

Author: sferik

lib/simplecov/formatter/html_formatter.rb

@@ -25,6 +25,7 @@ def initialize(silent: false, output_dir: nil)
       def format(result)
         json = JSON.pretty_generate(JSONFormatter.build_hash(result))
 
+        FileUtils.mkdir_p(output_path)
         File.write(File.join(output_path, JSONFormatter::FILENAME), json)
         File.write(File.join(output_path, DATA_FILENAME), "window.SIMPLECOV_DATA = #{json};\n", mode: "wb")
 

lib/simplecov/formatter/json_formatter.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "json_formatter/result_hash_formatter"
+require "fileutils"
 require "json"
 require "time"
 
@@ -26,6 +27,7 @@ def self.build_hash(result)
       end
 
       def format(result)
+        FileUtils.mkdir_p(output_path)
         path = File.join(output_path, FILENAME)
         warn_if_concurrent_overwrite(path)
         File.write(path, JSON.pretty_generate(self.class.build_hash(result)))

spec/helper.rb

@@ -1,5 +1,14 @@
 # frozen_string_literal: true
 
+# Dogfood: start Ruby's Coverage module *before* requiring simplecov so
+# simplecov's own lib/ files get tracked. Set SIMPLECOV_NO_DOGFOOD=1 to
+# skip — useful when running individual specs interactively or when a
+# dependency's behaviour around Coverage is being investigated.
+unless ENV["SIMPLECOV_NO_DOGFOOD"]
+  require "coverage"
+  Coverage.start(lines: true)
+end
+
 require "rspec"
 require "stringio"
 require "open3"
@@ -10,6 +19,40 @@
 
 SimpleCov.coverage_dir("tmp/coverage")
 
+unless ENV["SIMPLECOV_NO_DOGFOOD"]
+  # `start_tracking` (not `start`) handles bookkeeping (pid,
+  # process_start_time, fork hook) without auto-installing the at_exit
+  # formatter — the after(:suite) hook below drives the report
+  # ourselves at a controlled point. Filters are passed explicitly to
+  # the dogfood `Result.new`, not into `SimpleCov.filters`, so they
+  # don't leak into synthetic Results that unit tests build from
+  # `spec/fixtures/*` paths.
+  SimpleCov.start_tracking
+
+  DOGFOOD_OUTPUT_DIR = "tmp/dogfood"
+  DOGFOOD_MINIMUM_COVERAGE = 100.0
+
+  RSpec.configure do |config|
+    config.after(:suite) do
+      extra_filters = %w[/spec/ /features/ /test_projects/ /tmp/].map { |path| SimpleCov::StringFilter.new(path) }
+      raw = SimpleCov::UselessResultsRemover.call(Coverage.result)
+      adapted = SimpleCov::ResultAdapter.call(raw)
+      result = SimpleCov::Result.new(adapted, filters: SimpleCov.filters + extra_filters, groups: {})
+
+      SimpleCov::Formatter::HTMLFormatter.new(silent: true, output_dir: DOGFOOD_OUTPUT_DIR).format(result)
+      percent = result.covered_percent
+      next if percent >= DOGFOOD_MINIMUM_COVERAGE
+
+      $stdout.puts format(
+        "Dogfood line coverage (%<actual>.2f%%) is below threshold (%<expected>.2f%%). " \
+        "See %<dir>s/index.html",
+        actual: percent, expected: DOGFOOD_MINIMUM_COVERAGE, dir: DOGFOOD_OUTPUT_DIR
+      )
+      Kernel.exit(SimpleCov::ExitCodes::MINIMUM_COVERAGE)
+    end
+  end
+end
+
 def source_fixture(filename)
   File.join(source_fixture_base_directory, "fixtures", filename)
 end

spec/simplecov_spec.rb

@@ -372,6 +372,16 @@ def expect_merged
       described_class.clear_coverage_criteria
     end
 
+    before do
+      # `start_coverage_with_criteria` short-circuits with `unless
+      # Coverage.running?`. These tests verify the kwargs handed to
+      # Coverage.start, which only fire when Coverage isn't already
+      # running — so stub the running check to false. (Without this,
+      # the test would fail when run with the dogfood bootstrap, which
+      # starts Coverage before requiring simplecov.)
+      allow(Coverage).to receive(:running?).and_return(false)
+    end
+
     it "starts coverage in lines mode by default" do
       allow(Coverage).to receive(:start)