Raise an exception instead of changing exit code

It think it's louder and clearer that way

Also avoid checking coverage and failing after our own test case is finished
by disabling exit handler via Test.uninstall

And move setup/handling at_exit from Configuration to Test

Author: ahx

lib/openapi_first/test.rb

@@ -8,6 +8,8 @@ module Test
     autoload :Coverage, 'openapi_first/test/coverage'
     autoload :Methods, 'openapi_first/test/methods'
 
+    class CoverageError < Error; end
+
     def self.minitest?(base)
       base.include?(::Minitest::Assertions)
     rescue NameError
@@ -39,13 +41,30 @@ def self.setup
               "OpenapiFirst::Test.setup { |test| test.register('myopenapi.yaml') }"
       end
 
-      return unless configuration.report_coverage
+      @exit_handler = method(:handle_exit)
 
       @setup ||= at_exit do
-        configuration.handle_exit
+        # :nocov:
+        @exit_handler&.call
+        # :nocov:
       end
     end
 
+    def self.handle_exit
+      return unless configuration.report_coverage
+
+      report_coverage(
+        formatter: configuration.coverage_formatter,
+        **configuration.coverage_formatter_options
+      )
+      return unless configuration.report_coverage == true
+
+      coverage = Coverage.result.coverage
+      return if coverage >= configuration.minimum_coverage
+
+      raise OpenapiFirst::Test::CoverageError, 'Not all described requests and responses have been tested.'
+    end
+
     # Print the coverage report
     # @param formatter A formatter to define the report.
     # @output [IO] An output where to puts the report.
@@ -87,6 +106,7 @@ def self.uninstall
       definitions.clear
       @configuration = nil
       @installed = nil
+      @exit_handler = nil
     end
 
     class NotRegisteredError < StandardError; end

lib/openapi_first/test/configuration.rb

@@ -46,23 +46,6 @@ def skip_response_coverage_if(&block)
 
       # TODO: Deprecate skip_response_coverage
       alias skip_response_coverage skip_response_coverage_if
-
-      # This called at_exit
-      def handle_exit
-        return unless report_coverage
-
-        Test.report_coverage(
-          formatter: coverage_formatter,
-          **coverage_formatter_options
-        )
-        coverage = Coverage.result.coverage
-        return if coverage >= minimum_coverage
-
-        return unless report_coverage == true
-
-        warn 'OpenapiFirst::Test failed with exit 2, because not all described requests/responses have been tested.'
-        exit 2
-      end
     end
   end
 end

spec/test/configuration_spec.rb

@@ -3,93 +3,9 @@
 RSpec.describe OpenapiFirst::Test::Configuration do
   subject(:configuration) { described_class.new }
 
-  describe '#handle_exit' do
-    it 'reports coverage and fails' do
-      expect(OpenapiFirst::Test).to receive(:report_coverage)
-      expect do
-        configuration.handle_exit
-      end.to raise_error(SystemExit)
-    end
-
-    it 'raises an error with invalid option value' do
-      expect do
-        configuration.report_coverage = :fatal
-      end.to raise_error(ArgumentError)
-    end
-
-    context 'with full coverage' do
-      let(:definition) do
-        OpenapiFirst.parse(YAML.load(%(
-          openapi: 3.1.0
-          info:
-            title: Dice
-            version: 1
-          paths:
-            "/roll":
-              post:
-                responses:
-                  '200':
-                    content:
-                      application/json:
-                        schema:
-                          type: integer
-                          min: 1
-                          max:
-        )))
-      end
-
-      before do
-        valid_request = Rack::Request.new(Rack::MockRequest.env_for('/roll', method: 'POST'))
-        valid_response = Rack::Response[200, { 'content-type' => 'application/json' }, ['1']]
-        OpenapiFirst::Test.setup { |test| test.register(definition) }
-        definition.validate_request(valid_request)
-        definition.validate_response(valid_request, valid_response)
-      end
-
-      it 'reports coverage but does not fail' do
-        expect(OpenapiFirst::Test).to receive(:report_coverage)
-
-        expect do
-          configuration.handle_exit
-        end.not_to raise_error(SystemExit)
-      end
-    end
-
-    context 'with report_coverage = true' do
-      before do
-        configuration.report_coverage = true
-      end
-
-      it 'reports coverage' do
-        expect(OpenapiFirst::Test).to receive(:report_coverage)
-        expect do
-          configuration.handle_exit
-        end.to raise_error(SystemExit)
-      end
-    end
-
-    context 'with report_coverage = false' do
-      before do
-        configuration.report_coverage = false
-      end
-
-      it 'does not report coverage' do
-        expect(OpenapiFirst::Test).not_to receive(:report_coverage)
-
-        configuration.handle_exit
-      end
-    end
-
-    context 'with report_coverage = :warn' do
-      before do
-        configuration.report_coverage = :warn
-      end
-
-      it 'reports coverage, but does not fail' do
-        expect(OpenapiFirst::Test).to receive(:report_coverage)
-
-        configuration.handle_exit
-      end
-    end
+  it 'raises an error with invalid option value' do
+    expect do
+      configuration.report_coverage = :fatal
+    end.to raise_error(ArgumentError)
   end
 end

spec/test_spec.rb

@@ -3,10 +3,6 @@
 require 'minitest'
 
 RSpec.describe OpenapiFirst::Test do
-  before do
-    described_class.configuration.report_coverage = false
-  end
-
   describe '.minitest?' do
     it 'detects minitest' do
       test_case = Class.new(Minitest::Test)
@@ -122,6 +118,94 @@
     end
   end
 
+  describe '#handle_exit' do
+    let(:configuration) { described_class.configuration }
+
+    before do
+      configuration.report_coverage = true
+    end
+
+    it 'reports coverage and fails' do
+      expect(OpenapiFirst::Test).to receive(:report_coverage)
+      expect do
+        described_class.handle_exit
+      end.to raise_error(OpenapiFirst::Test::CoverageError)
+    end
+
+    context 'with full coverage' do
+      let(:definition) do
+        OpenapiFirst.parse(YAML.load(%(
+          openapi: 3.1.0
+          info:
+            title: Dice
+            version: 1
+          paths:
+            "/roll":
+              post:
+                responses:
+                  '200':
+                    content:
+                      application/json:
+                        schema:
+                          type: integer
+                          min: 1
+                          max:
+        )))
+      end
+
+      before do
+        valid_request = Rack::Request.new(Rack::MockRequest.env_for('/roll', method: 'POST'))
+        valid_response = Rack::Response[200, { 'content-type' => 'application/json' }, ['1']]
+        OpenapiFirst::Test.setup { |test| test.register(definition) }
+        definition.validate_request(valid_request)
+        definition.validate_response(valid_request, valid_response)
+      end
+
+      it 'does not fail' do
+        expect do
+          described_class.handle_exit
+        end.not_to raise_error
+      end
+    end
+
+    context 'with report_coverage = true' do
+      before do
+        configuration.report_coverage = true
+      end
+
+      it 'reports coverage' do
+        expect(OpenapiFirst::Test).to receive(:report_coverage)
+        expect do
+          described_class.handle_exit
+        end.to raise_error(OpenapiFirst::Test::CoverageError)
+      end
+    end
+
+    context 'with report_coverage = false' do
+      before do
+        configuration.report_coverage = false
+      end
+
+      it 'does not report coverage' do
+        expect(OpenapiFirst::Test).not_to receive(:report_coverage)
+
+        described_class.handle_exit
+      end
+    end
+
+    context 'with report_coverage = :warn' do
+      before do
+        configuration.report_coverage = :warn
+      end
+
+      it 'reports coverage, but does not fail' do
+        expect(OpenapiFirst::Test).to receive(:report_coverage)
+
+        described_class.handle_exit
+      end
+    end
+  end
+
   describe '.report_coverage' do
     let(:output) { StringIO.new }