openapi_first 3.1.1 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 253737faf3fc405b3392732741837952f8be5082a53b5951f0eb7cfa3d19e15d
-  data.tar.gz: 9afffa2c557e0de2607c36ba271d93df6e02c291cabc0f8b7100efb2452e4d31
+  metadata.gz: 3d95e7c0085b398b3ec034554d30cf4bd6e9dc488c5cc19d7777ec88aa5ed9ec
+  data.tar.gz: 323d16c0d405b4233ebe4377cb1a9960db84d19033193d3ccf9badb052a00f24
 SHA512:
-  metadata.gz: 2336b176928f49a20717077619aab2bae0d5503e53d4c25f98407929488d99e0ad3bd22763a6afa41df3591b5e0f01bb99f304bae099c8f4679ff24132bcbfa5
-  data.tar.gz: 6c8186bb46f45f42b6aa1db24dc7886ee73733994108bfa2870c8ecba71a72d9a993bf7cf51c6facc676cfab0270328ca532a7780797614ef17222db97aa797a
+  metadata.gz: d80c5803dcb0746cdf9def8e1b470394b424926a2a0235da90bc47e3f748f74fdbf278cd8e7640b157aabe279e2028e80581f4a7ebcde4b4d1238e9ee0040618
+  data.tar.gz: 1022635f98bd37c776d137315fd61f9ba82dd72831ca16ef2e834f45bcba0456e90614eebc85df1fd08b7e03183daa16beaa098575d4161f74b54e3d1ef998b6

data/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 ## Unreleased
 
+## 3.2.0
+
+### Changed
+- Changed OpenapiFirst::Test to track the request _after_ the app has handled the request. See [PR #434](https://github.com/ahx/openapi_first/pull/434). You can restore the old behavior with 
+```ruby
+  include OpenapiFirst::Test::Methods[MyApp, validate_request_before_handling: true]
+```
+
+### Added
+
+- Added `OpenapiFirst::ValidatedRequest#unknown?` and `OpenapiFirst::ValidatedResponse#unknown?`
+- Added new hook: `after_response_body_property_validation`
+- Added support for a static `path_prefix` value to be set on the creation of a Definition. See [PR #432](https://github.com/ahx/openapi_first/pull/432):
+  ```ruby
+  OpenapiFirst.configure do |config|
+    config.register('openapi/openapi.yaml' path_prefix: '/weather')
+  end
+  ```
+- Added `OpenapiFirst::Test::Configuration#ignore_response_error` and `#ignore_request_error` to configure which request/response errors should not raise an error during testing:
+  ```ruby
+  OpenapiFirst::Test.setup do |test|
+    test.ignore_request_error do |validated_request|
+      # Ignore unknown requests on certain paths
+      validated_request.path.start_with?('/api/v1') && validated_request.unknown?
+    end
+    
+    test.ignore_response_error do |validated_response, rack_request|
+      # Ignore invalid response bodies on certain paths
+      validated_request.path.start_with?('/api/legacy/stuff') && validated_request.error.type ==  :invalid_body      
+    end
+  end
+  ```
+
 ## 3.1.1
 
 - Changed: Return uniqe errors in default error responses

data/README.md

@@ -231,6 +231,23 @@ Here is how to set it up:
 
 ### Configure test coverage
 
+You can ignore errors for certain requests/responses. This will stop `OpenapiFirst::Test` from raising an exception if the block returns true. 
+
+```ruby
+OpenapiFirst::Test.setup do |test|
+  test.ignore_request_error do |validated_request|
+    # Ignore unknown requests on certain paths
+    validated_request.path.start_with?('/api/v1') && validated_request.unknown?
+  end
+  
+  test.ignore_response_error do |validated_response, rack_request|
+    # Ignore invalid response bodies on certain paths
+    validated_request.path.start_with?('/api/legacy/stuff') && validated_request.error.type ==  :invalid_body      
+  end
+end
+```
+
+
 OpenapiFirst::Test raises an error when a response status is not defined except for 404 and 500. You can change this:
 
 ```ruby
@@ -368,6 +385,7 @@ Available hooks:
 - `after_response_validation`
 - `after_request_parameter_property_validation`
 - `after_request_body_property_validation`
+- `after_response_body_property_validation`
 
 Setup per per instance:
 

data/lib/openapi_first/builder.rb

@@ -165,7 +165,10 @@ module OpenapiFirst
       responses.flat_map do |status, response_object|
         headers = build_response_headers(response_object['headers'])
         response_object['content']&.map do |content_type, content_object|
-          content_schema = content_object['schema'].schema(configuration: schemer_configuration)
+          content_schema = content_object['schema'].schema(
+            configuration: schemer_configuration,
+            after_property_validation: config.after_response_body_property_validation
+          )
           Response.new(status:,
                        headers:,
                        content_type:,

data/lib/openapi_first/configuration.rb

@@ -8,6 +8,7 @@ module OpenapiFirst
       after_response_validation
       after_request_parameter_property_validation
       after_request_body_property_validation
+      after_response_body_property_validation
     ].freeze
 
     def initialize

data/lib/openapi_first/definition.rb

@@ -11,6 +11,8 @@ module OpenapiFirst
 
     # @return [String,nil]
     attr_reader :filepath
+    # @return [String,nil]
+    attr_reader :path_prefix
     # @return [Configuration]
     attr_reader :config
     # @return [Enumerable[String]]
@@ -20,8 +22,10 @@ module OpenapiFirst
 
     # @param contents [Hash] The OpenAPI document.
     # @param filepath [String] The file path of the OpenAPI document.
-    def initialize(contents, filepath = nil)
+    # @param path_prefix [String,nil] An optional path prefix, that is not documented, that all requests begin with.
+    def initialize(contents, filepath = nil, path_prefix = nil)
       @filepath = filepath
+      @path_prefix = path_prefix
       @config = OpenapiFirst.configuration.child
       yield @config if block_given?
       @config.freeze
@@ -79,23 +83,22 @@ module OpenapiFirst
     end
 
     # Validates the response against the API description.
-    # @param rack_request [Rack::Request] The Rack request object.
-    # @param rack_response [Rack::Response] The Rack response object.
-    # @param raise_error [Boolean] Whethir to raise an error if validation fails.
+    # @param request [Rack::Request] The Rack request object.
+    # @param response [Rack::Response] The Rack response object.
+    # @param raise_error [Boolean] Whether to raise an error if validation fails.
     # @return [ValidatedResponse] The validated response object.
-    def validate_response(rack_request, rack_response, raise_error: false)
-      route = @router.match(rack_request.request_method, resolve_path(rack_request),
-                            content_type: rack_request.content_type)
+    def validate_response(request, response, raise_error: false)
+      route = @router.match(request.request_method, resolve_path(request), content_type: request.content_type)
       return if route.error # Skip response validation for unknown requests
 
-      response_match = route.match_response(status: rack_response.status, content_type: rack_response.content_type)
+      response_match = route.match_response(status: response.status, content_type: response.content_type)
       error = response_match.error
       validated = if error
-                    ValidatedResponse.new(rack_response, error:)
+                    ValidatedResponse.new(response, error:)
                   else
-                    response_match.response.validate(rack_response)
+                    response_match.response.validate(response)
                   end
-      @config.after_response_validation&.each { |hook| hook.call(validated, rack_request, self) }
+      @config.after_response_validation&.each { |hook| hook.call(validated, request, self) }
       raise validated.error.exception(validated) if raise_error && validated.invalid?
 
       validated
@@ -104,6 +107,7 @@ module OpenapiFirst
     private
 
     def resolve_path(rack_request)
+      return rack_request.path.delete_prefix(path_prefix) if path_prefix && rack_request.path.start_with?(path_prefix)
       return rack_request.path unless @config.path
 
       @config.path.call(rack_request)

data/lib/openapi_first/test/app.rb

@@ -10,16 +10,24 @@ module OpenapiFirst
     # A wrapper of the original app
     # with silent request/response validation to track requests/responses.
     class App < SimpleDelegator
-      def initialize(app, api:)
+      def initialize(app, api:, validate_request_before_handling:)
         super(app)
         @app = app
         @definition = Test[api]
+        @validate_request_before_handling = validate_request_before_handling
       end
 
       def call(env)
         request = Rack::Request.new(env)
-        env[Test::REQUEST] = @definition.validate_request(request, raise_error: false)
+        if @validate_request_before_handling
+          env[Test::REQUEST] = @definition.validate_request(request, raise_error: false)
+        end
+
         response = @app.call(env)
+        unless @validate_request_before_handling
+          env[Test::REQUEST] = @definition.validate_request(request, raise_error: false)
+        end
+
         status, headers, body = response
         env[Test::RESPONSE] =
           @definition.validate_response(request, Rack::Response[status, headers, body], raise_error: false)

data/lib/openapi_first/test/configuration.rb

@@ -15,6 +15,8 @@ module OpenapiFirst
         @ignore_unknown_response_status = false
         @report_coverage = true
         @ignore_unknown_requests = false
+        @ignore_request_error = nil
+        @ignore_response_error = nil
       end
 
       # Register OADs, but don't load them just yet
@@ -50,6 +52,23 @@ module OpenapiFirst
         @report_coverage = value
       end
 
+      # Ignore certain errors for certain requests
+      # @param block A Proc that will be called with [OpenapiFirst::ValidatedRequest]
+      def ignore_request_error(&block)
+        raise ArgumentError, 'You have to pass a block' unless block_given?
+
+        @ignore_request_error = block
+      end
+
+      # Ignore certain errors for certain responses
+      # @param block A Proc that will be called with [OpenapiFirst::ValidatedResponse, Rack::Request]
+      def ignore_response_error(&block)
+        raise ArgumentError, 'You have to pass a block' unless block_given?
+
+        @ignore_response_error = block
+      end
+
+      # @param block A Proc that will be called with [OpenapiFirst::ValidatedResponse, Rack::Request]
       def skip_response_coverage(&block)
         return @skip_response_coverage unless block_given?
 
@@ -63,13 +82,22 @@ module OpenapiFirst
       end
 
       alias ignore_unknown_response_status? ignore_unknown_response_status
+      alias ignore_unknown_requests? ignore_unknown_requests
 
-      def ignore_response?(validated_response)
-        return false if validated_response.known?
+      def raise_request_error?(validated_request)
+        return false if @ignore_request_error&.call(validated_request)
+        return false if ignore_unknown_requests? && validated_request.unknown?
+
+        validated_request.unknown?
+      end
 
-        return true if ignored_unknown_status.include?(validated_response.status)
+      def raise_response_error?(validated_response, rack_request)
+        return false if @ignore_response_error&.call(validated_response, rack_request)
+        return false if response_raise_error == false
+        return false if ignored_unknown_status.include?(validated_response.status)
+        return false if ignore_unknown_response_status? && validated_response.error.type == :response_status_not_found
 
-        ignore_unknown_response_status? && validated_response.error.type == :response_status_not_found
+        true
       end
     end
   end

data/lib/openapi_first/test/methods.rb

@@ -12,12 +12,13 @@ module OpenapiFirst
         base.include(AssertionMethod)
       end
 
-      def self.[](application_under_test = nil, api: nil)
+      def self.[](application_under_test = nil, api: nil, validate_request_before_handling: false)
         mod = Module.new do
           def self.included(base)
             base.include OpenapiFirst::Test::Methods::AssertionMethod
           end
         end
+        mod.define_method(:openapi_first_validate_request_before_handling?) { validate_request_before_handling }
 
         if api
           mod.define_method(:openapi_first_default_api) { api }
@@ -26,7 +27,12 @@ module OpenapiFirst
         end
 
         if application_under_test
-          mod.define_method(:app) { OpenapiFirst::Test.app(application_under_test, api: openapi_first_default_api) }
+          mod.define_method(:app) do
+            OpenapiFirst::Test.app(
+              application_under_test, api: openapi_first_default_api,
+                                      validate_request_before_handling: openapi_first_validate_request_before_handling?
+            )
+          end
         end
 
         mod

data/lib/openapi_first/test/observe.rb

@@ -23,7 +23,7 @@ module OpenapiFirst
           return
         end
 
-        unless app.instance_methods.include?(:call)
+        unless app.method_defined?(:call)
           raise ObserveError, "Don't know how to observe #{app}, because it has no call instance method."
         end
 

data/lib/openapi_first/test.rb

@@ -40,7 +40,7 @@ module OpenapiFirst
     end
 
     # Sets up OpenAPI test coverage and OAD registration.
-    # @yieldparam [OpenapiFirst::Test::Configuration] configuration A configuration to setup test integration
+    # @yield [OpenapiFirst::Test::Configuration] configuration A configuration to setup test integration
     def self.setup
       install
       yield configuration if block_given?
@@ -95,9 +95,9 @@ module OpenapiFirst
     # Returns the Rack app wrapped with silent request, response validation
     # You can use this if you want to track coverage via Test::Coverage, but don't want to use
     # the middlewares or manual request, response validation.
-    def self.app(app, spec: nil, api: :default)
+    def self.app(app, spec: nil, api: :default, validate_request_before_handling: false)
       spec ||= self[api]
-      App.new(app, api: spec)
+      App.new(app, api: spec, validate_request_before_handling:)
     end
 
     def self.install
@@ -115,9 +115,7 @@ module OpenapiFirst
 
         @after_response_validation = config.after_response_validation do |validated_response, rack_request, oad|
           next unless registered?(oad)
-          if validated_response.invalid? && raise_response_error?(validated_response)
-            raise validated_response.error.exception
-          end
+          raise validated_response.error.exception if raise_response_error?(validated_response, rack_request)
 
           Coverage.track_response(validated_response, rack_request, oad)
         end
@@ -156,15 +154,16 @@ module OpenapiFirst
 
       def raise_request_error?(validated_request)
         return false if validated_request.valid?
-        return false if validated_request.known?
 
-        !configuration.ignore_unknown_requests
+        configuration.raise_request_error?(validated_request)
       end
 
       def many?(array) = array.length > 1
 
-      def raise_response_error?(invalid_response)
-        configuration.response_raise_error && !configuration.ignore_response?(invalid_response)
+      def raise_response_error?(validated_response, rack_request)
+        return false if validated_response.valid?
+
+        configuration.raise_response_error?(validated_response, rack_request)
       end
     end
   end

data/lib/openapi_first/validated_request.rb

@@ -69,6 +69,9 @@ module OpenapiFirst
     # Returns true if the request is defined.
     def known? = request_definition != nil
 
+    # Returns true if the request is not defined.
+    def unknown? = !known?
+
     # Merged path, query, body parameters.
     # Here path has the highest precedence, then query, then body.
     # @return [Hash<String, anything>]

data/lib/openapi_first/validated_response.rb

@@ -44,6 +44,9 @@ module OpenapiFirst
     # Returns true if the response is defined.
     def known? = response_definition != nil
 
+    # Returns true if the response is not defined.
+    def unknown? = !known?
+
     # Checks if the response is invalid.
     # @return [Boolean]
     def invalid?

data/lib/openapi_first/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OpenapiFirst
-  VERSION = '3.1.1'
+  VERSION = '3.2.0'
 end

data/lib/openapi_first.rb

@@ -55,8 +55,11 @@ module OpenapiFirst
 
   # Load and dereference an OpenAPI spec file or return the Definition if it's already loaded
   # @param filepath_or_definition [String, Definition] The path to the file or a Definition object
+  # @param only [Proc, nil] An optional proc to filter paths. It is called with the path string and should return
+  # true/false
+  # @param path_prefix [String, nil] An optional path prefix, that is not documented, that all requests begin with.
   # @return [Definition]
-  def self.load(filepath_or_definition, only: nil, &)
+  def self.load(filepath_or_definition, only: nil, path_prefix: nil, &)
     return filepath_or_definition if filepath_or_definition.is_a?(Definition)
     return self[filepath_or_definition] if filepath_or_definition.is_a?(Symbol)
 
@@ -64,16 +67,16 @@ module OpenapiFirst
     raise FileNotFoundError, "File not found: #{filepath}" unless File.exist?(filepath)
 
     contents = FileLoader.load(filepath)
-    parse(contents, only:, filepath:, &)
+    parse(contents, only:, filepath:, path_prefix:, &)
   end
 
   # Parse a dereferenced Hash
   # @return [Definition]
   # TODO: This needs to work with unresolved contents as well
-  def self.parse(contents, only: nil, filepath: nil, &)
+  def self.parse(contents, only: nil, filepath: nil, path_prefix: nil, &)
     contents = ::JSON.parse(::JSON.generate(contents)) # Deeply stringify keys, because of YAML. See https://github.com/ahx/openapi_first/issues/367
     contents['paths'].filter!(&->(key, _) { only.call(key) }) if only
-    Definition.new(contents, filepath, &)
+    Definition.new(contents, filepath, path_prefix, &)
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openapi_first
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.2.0
 platform: ruby
 authors:
 - Andreas Haller