Merge pull request #393 from ahx/ignore_all_unknown_status

Add `Test::Configuration#ignore_all_unknown_status = true`

Author: ahx

CHANGELOG.md

@@ -2,7 +2,8 @@
 
 ## Unreleased
 
-- Add `OpenapiFirst::Test::Configuration#ignore_unknown_responses=` (use only temporarily when working with an unmaintained OAD)
+- Add `OpenapiFirst::Test::Configuration#ignore_all_unknown_status=`. When this is set to true, it won't complain about undefined response statuses it sees during a test run. Use with caution.
+- Failure type `:response_not_found` was split into two more specific types `:response_content_type_not_found` and `:response_status_not_found`. This should be mostly internal stuff.
 
 ## 2.11.1
 

README.md

@@ -211,6 +211,15 @@ OpenapiFirst::Test.setup do |test|
 end
 ```
 
+Or you can ignore all unknown response status:
+
+```ruby
+OpenapiFirst::Test.setup do |test|
+  # …
+  test.ignore_all_unknown_status = true
+end
+```
+
 Exclude certain _responses_ from coverage with `skip_coverage`:
 
 ```ruby

lib/openapi_first/failure.rb

@@ -13,7 +13,8 @@ class Failure
       invalid_header: [RequestInvalidError, 'Request header is invalid:'],
       invalid_path: [RequestInvalidError, 'Path segment is invalid:'],
       invalid_cookie: [RequestInvalidError, 'Cookie value is invalid:'],
-      response_not_found: [ResponseNotFoundError],
+      response_content_type_not_found: [ResponseNotFoundError],
+      response_status_not_found: [ResponseNotFoundError],
       invalid_response_body: [ResponseInvalidError, 'Response body is invalid:'],
       invalid_response_header: [ResponseInvalidError, 'Response header is invalid:']
     }.freeze

lib/openapi_first/router/find_response.rb

@@ -10,30 +10,34 @@ module FindResponse
 
       def self.call(responses, status, content_type, request_method:, path:)
         contents = find_status(responses, status)
-        if contents.nil?
-          message = "Status #{status} is not defined for #{request_method.upcase} #{path}. " \
-                    "Defined statuses are: #{responses.keys.join(', ')}."
-          return Match.new(error: Failure.new(:response_not_found, message:), response: nil)
-        end
+        return response_status_not_found(status:, request_method:, path:, responses:) if contents.nil?
+
         response = FindContent.call(contents, content_type)
-        return response_not_found(content_type:, contents:, request_method:, path:) unless response
+        return response_content_type_not_found(content_type:, contents:, request_method:, path:) unless response
 
         Match.new(response:, error: nil)
       end
 
-      def self.response_not_found(content_type:, contents:, request_method:, path:)
+      def self.response_content_type_not_found(content_type:, contents:, request_method:, path:)
         empty_content = content_type.nil? || content_type.empty?
         message =
           "Content-Type should be #{contents.keys.join(' or ')}, " \
           "but was #{empty_content ? 'empty' : content_type} for " \
           "#{request_method.upcase} #{path}"
 
         Match.new(
-          error: Failure.new(:response_not_found, message:),
+          error: Failure.new(:response_content_type_not_found, message:),
           response: nil
         )
       end
-      private_class_method :response_not_found
+      private_class_method :response_content_type_not_found
+
+      def self.response_status_not_found(status:, request_method:, path:, responses:)
+        message = "Status #{status} is not defined for #{request_method.upcase} #{path}. " \
+                  "Defined statuses are: #{responses.keys.join(', ')}."
+        Match.new(error: Failure.new(:response_status_not_found, message:), response: nil)
+      end
+      private_class_method :response_status_not_found
 
       def self.find_status(responses, status)
         # According to OAS status has to be a string,

lib/openapi_first/test.rb

@@ -123,8 +123,8 @@ def self.raise_request_error?(validated_request)
       !configuration.ignore_unknown_requests
     end
 
-    def self.raise_response_error?(validated_response)
-      configuration.response_raise_error && !configuration.ignore_response?(validated_response)
+    def self.raise_response_error?(invalid_response)
+      configuration.response_raise_error && !configuration.ignore_response?(invalid_response)
     end
 
     def self.uninstall

lib/openapi_first/test/configuration.rb

@@ -12,7 +12,7 @@ def initialize
         @skip_coverage = nil
         @response_raise_error = true
         @ignored_unknown_status = [404]
-        @ignore_unknown_responses = false
+        @ignore_all_unknown_response_status = false
         @report_coverage = true
         @ignore_unknown_requests = false
         @registry = {}
@@ -32,7 +32,7 @@ def observe(app, api: :default)
       end
 
       attr_accessor :coverage_formatter_options, :coverage_formatter, :response_raise_error,
-                    :ignore_unknown_requests, :ignore_unknown_responses
+                    :ignore_unknown_requests, :ignore_all_unknown_response_status
       attr_reader :registry, :apps, :report_coverage, :ignored_unknown_status, :minimum_coverage
 
       # Configure report coverage
@@ -65,10 +65,14 @@ def skip_coverage(&block)
         @skip_coverage = block
       end
 
+      alias ignore_all_unknown_response_status? ignore_all_unknown_response_status
+
       def ignore_response?(validated_response)
-        return true if @ignore_unknown_responses
+        return false if validated_response.known?
+
+        return true if ignored_unknown_status.include?(validated_response.status)
 
-        ignored_unknown_status.include?(validated_response.status)
+        ignore_all_unknown_response_status? && validated_response.error.type == :response_status_not_found
       end
     end
   end

spec/router/find_response_spec.rb

@@ -57,7 +57,7 @@ def find(responses, status, content_type)
         ]
         expect(find(responses, 409, 'application/json')).to have_attributes(
           response: nil, error: have_attributes(
-            type: :response_not_found,
+            type: :response_status_not_found,
             message: 'Status 409 is not defined for GET /stations. Defined statuses are: 200, 201.'
           )
         )
@@ -85,7 +85,7 @@ def find(responses, status, content_type)
         message = 'Content-Type should be application/text or application/xml, but was application/json for GET /stations'
         expect(find(responses, 200, 'application/json')).to have_attributes(
           response: nil,
-          error: have_attributes(type: :response_not_found, message:)
+          error: have_attributes(type: :response_content_type_not_found, message:)
         )
       end
     end

spec/test/configuration_spec.rb

@@ -23,7 +23,7 @@
   describe '#ignore_response?' do
     let(:valid_response) { double(valid?: true, known?: true, status: 302) }
     let(:invalid_response) { double(valid?: false, known?: true, status: 302) }
-    let(:unknown_response) { double(valid?: false, known?: false, status: 302) }
+    let(:unknown_response_status) { double(valid?: false, known?: false, status: 302, error: OpenapiFirst::Failure.new(:response_status_not_found)) }
 
     it 'returns false by default for a valid responses' do
       expect(configuration.ignore_response?(valid_response)).to eq(false)
@@ -34,22 +34,33 @@
     end
 
     it 'returns false by default for an unkonwn responses' do
-      expect(configuration.ignore_response?(unknown_response)).to eq(false)
+      expect(configuration.ignore_response?(unknown_response_status)).to eq(false)
     end
 
     context 'when status is ignored' do
-      before { configuration.ignored_unknown_status << invalid_response.status }
+      before { configuration.ignored_unknown_status << unknown_response_status.status }
 
-      it 'returns true' do
-        expect(configuration.ignore_response?(invalid_response)).to eq(true)
+      it 'returns true for an unknown response with that status' do
+        expect(configuration.ignore_response?(unknown_response_status)).to eq(true)
+      end
+
+      it 'returns false for an unknown response with another status' do
+        unknown_response_status = double(valid?: false, known?: false, status: 409)
+        expect(configuration.ignore_response?(unknown_response_status)).to eq(false)
       end
     end
 
-    context 'when all responses are ignored' do
-      before { configuration.ignore_unknown_responses = true }
+    context 'when all unknown response status are ignored' do
+      before { configuration.ignore_all_unknown_response_status = true }
+
+      it 'returns true for any unknown response status' do
+        expect(configuration.ignore_response?(unknown_response_status)).to eq(true)
+      end
+
+      it 'returns false for an unknown response with a known status' do
+        unknown_response_content_type = double(valid?: false, known?: false, status: 302, error: OpenapiFirst::Failure.new(:response_content_type_not_found))
 
-      it 'returns true' do
-        expect(configuration.ignore_response?(invalid_response)).to eq(true)
+        expect(configuration.ignore_response?(unknown_response_content_type)).to eq(false)
       end
     end
   end

spec/test_spec.rb

@@ -606,10 +606,20 @@ def call(_env)
       end
     end
 
-    it 'raises an error' do
-      expect do
-        app.call(Rack::MockRequest.env_for('/roll', method: 'POST'))
-      end.to raise_error(OpenapiFirst::ResponseNotFoundError)
+    context 'when response status is unknown' do
+      it 'raises an error' do
+        expect do
+          app.call(Rack::MockRequest.env_for('/roll', method: 'POST'))
+        end.to raise_error(OpenapiFirst::ResponseNotFoundError)
+      end
+    end
+
+    context 'when response content-type is unknown' do
+      it 'raises an error' do
+        expect do
+          app.call(Rack::MockRequest.env_for('/roll', method: 'POST'))
+        end.to raise_error(OpenapiFirst::ResponseNotFoundError)
+      end
     end
 
     context 'with ignored_unknown_status' do
@@ -624,9 +634,9 @@ def call(_env)
       end
     end
 
-    context 'with ignore_unknown_responses = true' do
+    context 'with ignore_all_unknown_response_status = true' do
       before(:each) do
-        described_class.configuration.ignore_unknown_responses = true
+        described_class.configuration.ignore_all_unknown_response_status = true
       end
 
       it 'does not raise an error' do