openapi_first 1.4.3 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65d3a7d13fef3df69dbbbe5c42fae60a977f56dd044ce712a9826b1489c1b001
-  data.tar.gz: 54c3fd940b948a6c72f001e02a011882f60dbb06c7e7ea0b1660657c949f3d15
+  metadata.gz: 87fceda33e397fa75a8268144e5cbacfb802333a5ef1c315676d14458312b01b
+  data.tar.gz: a734ee73e2dce89fea8d2fc93c713b0505923b2b2098b560a2b44ef3e5753c84
 SHA512:
-  metadata.gz: 0cd9e2433e14958f762282293ea2f2dff45ec984d406386eb9cb43d5277ba96eb0b7a31f6a8747a2ba5747a1374be72bc86116470fbe266b8c05a5f72daee12e
-  data.tar.gz: c2e7aab524164d310570fab575f9ff5c0b891f1501f90b0d6fe6f8265e028cd543fd22c64fb99a4227b488f340da4947f69b0988f8e3c9315df2c17bb7089762
+  metadata.gz: 63d51c543d3d689ced06170e1e53f6d0a20056af2643e1f1fccfbf966b14352c55ad9c0dfd92478ceb7e5aaac0b6f7c7563e17d9e69ab2f924f6a9d4846c45ff
+  data.tar.gz: 8649d5737439a2414802e17ed562a0efdf294f29e7515b0e248e5736cd59235eba876baf52aad8e5d602ff90ba5afc8902ed1609d902dfe03c65d4136afc1042

data/CHANGELOG.md

@@ -2,6 +2,53 @@
 
 ## Unreleased
 
+## 2.0.2
+
+- Fix setting custom error response (thanks @gobijan)
+
+## 2.0.1 (Janked)
+
+## 2.0.0
+
+### New Features
+- Test Assertions! 📋 You can now use `assert_api_conform`  for contract testing in your rack-test / Rails integration tests. See Readme for details.
+
+- New option for `Middlewares::ResponseValidation`: `:raise_error` (default: true). If set to `false`, the middleware will not aise an error if the response is invalid. 🤫
+
+- Hooks 🪝🪝 (see Readme for details). You can use these to collect metrics, write error logs etc.:
+  - `after_request_validation`
+  - `after_response_validation`
+  - `after_request_body_property_validation`
+  - `after_request_parameter_property_validation`
+
+- Exceptions such as `OpenapiFirst::ResponseInvalidError` not respond to `#request` to get information about the validated request 💁🏻
+
+- Performance improvements 🚴🏻‍♀️
+
+- Validation failures returned by `ValidatedRequest#error` always returns a `#message`. So you can call `my_validated_request.error.message if validated_request.invalid?` and always get a human-readable error message. 😴
+
+### Breaking Changes
+
+#### Manual validation
+- `Definition#request.validate` was removed. Please use `Definition#validate_request` instead.
+- `Definition#validate_request` returns a `ValidatedRequest` which delgates all methods to the original (rack) request, except for `#valid?` `#parsed_body`. `#parsed_query`, `#operation` etc. See Readme for details.
+- The `Operation` class was removed. `ValidatedRequest#operation` now returns the OpenAPI 3 operation object as a plain Hash. So you can still call `ValidatedRequest#operation['x-foo']`. You can call `ValidatedRequest#operation_id` if you just need the _operationId_.
+-
+
+#### Inspecting OpenAPI files
+
+- `Definition#operations` has been removed. Please use `Definition#routes`, which returns a list of routes. Routes have a `#path`, `#request_method`, `#requests` and `#responses`.
+A route has one path and one request method, but can have multiple requests (one for each supported content-type) and responses (statuses + content-type).
+
+- Several internal changes to make the code more maintainable, more performant , support hooks and prepare for OpenAPI 4. If you have monkey-patched OpenapiFirst, you might need to adjust your code. Please contact me if you need help.
+
+### Deprecations
+
+#### Custom error responses
+
+- `ValidationError#error`, `#instance_location` and `#schema_location` have been deprecated. Use `ValidationError#message`, `#data_pointer` and `#schema_pointer` instead.
+- `Failure#error_type` has been deprecated. Use `#type` instead
+
 ## 1.4.3
 
 - Allow using json_schemer 2...3
@@ -27,7 +74,7 @@ Some redundant methods to validate or inspect requests/responses will be removed
 
 ## 1.3.6
 
-- Fix Rack 2 / Rails 6 compatibility ([#246](https://github.com/ahx/openapi_first/issues/246)
+- Fixed Rack 2 / Rails 6 compatibility ([#246](https://github.com/ahx/openapi_first/issues/246)
 
 ## 1.3.5
 
@@ -37,6 +84,7 @@ Some redundant methods to validate or inspect requests/responses will be removed
 
 - Fixed handling "binary" format in optional multipart file uploads
 - Cache the resolved OAD. This especially makes things run faster in tests.
+- Internally used `Operation#query_parameters`, `Operation#path_parameters` etc. now only returns parameters that are defined on the operation level not on the PathItem. Use `PathItem#query_parameters` to get those.
 
 ## 1.3.3 (yanked)
 

data/README.md

@@ -9,11 +9,13 @@ OpenapiFirst helps to implement HTTP APIs based on an [OpenAPI](https://www.open
 - [Rack Middlewares](#rack-middlewares)
   - [Request validation](#request-validation)
   - [Response validation](#response-validation)
+- [Test assertions](#test-assertions)
 - [Manual use](#manual-use)
   - [Validate request](#validate-request)
   - [Validate response](#validate-response)
-- [Configuration](#configuration)
 - [Framework integration](#framework-integration)
+- [Configuration](#configuration)
+- [Hooks](#hooks)
 - [Alternatives](#alternatives)
 - [Development](#development)
   - [Benchmarks](#benchmarks)
@@ -23,13 +25,9 @@ OpenapiFirst helps to implement HTTP APIs based on an [OpenAPI](https://www.open
 
 ## Rack Middlewares
 
-All middlewares add a _request_ object to the current Rack env at `env[OpenapiFirst::REQUEST]`), which is in an instance of `OpenapiFirst::RuntimeRequest` that responds to `.params`, `.parsed_body` etc.
-
-This gives you access to the converted request parameters and body exaclty as described in your API description instead of relying on Rack alone to parse the request. This only includes query parameters that are defined in the API description. It supports every [`style` and `explode` value as described](https://spec.openapis.org/oas/latest.html#style-examples) in the OpenAPI 3.0 and 3.1 specs.
-
 ### Request validation
 
-The request validation middleware returns a 4xx if the request is invalid or not defined in the API description.
+The request validation middleware returns a 4xx if the request is invalid or not defined in the API description. It adds a request object to the current Rack environment at `env[OpenapiFirst::REQUEST]` with the request parameters parsed exaclty as described in your API description plus access to meta information from your API description. See _[Manual use](#manual-use)_ for more details about that object.
 
 ```ruby
 use OpenapiFirst::Middlewares::RequestValidation, spec: 'openapi.yaml'
@@ -123,6 +121,7 @@ use OpenapiFirst::Middlewares::RequestValidation, spec: 'openapi.yaml, error_res
 #### Custom error responses
 
 You can build your own custom error response with `error_response: MyCustomClass` that implements `OpenapiFirst::ErrorResponse`.
+You can define custom error responses globally by including / implementing `OpenapiFirst::ErrorResponse` and register it via `OpenapiFirst.register_error_response(my_name, MyCustomErrorResponse)` and set `error_response: my_name`.
 
 #### readOnly / writeOnly properties
 
@@ -132,7 +131,7 @@ Response validation fails if response body includes a property with `writeOnly:
 
 ### Response validation
 
-This middleware is especially useful when testing. It _always_ raises an error if the response is not valid.
+This middleware is especially useful when testing. It raises an error by default if the response is not valid.
 
 ```ruby
 use OpenapiFirst::Middlewares::ResponseValidation, spec: 'openapi.yaml' if ENV['RACK_ENV'] == 'test'
@@ -143,6 +142,37 @@ use OpenapiFirst::Middlewares::ResponseValidation, spec: 'openapi.yaml' if ENV['
 | Name    | Possible values | Description                                                      |
 | :------ | --------------- | ---------------------------------------------------------------- |
 | `spec:` |                 | The path to the spec file or spec loaded via `OpenapiFirst.load` |
+| `raise_error:`    | `true` (default), `false`                                                | If set to true the middleware raises `OpenapiFirst::ResponseInvalidError` or `OpenapiFirst::ResonseNotFoundError` if the response does not match the API description. |
+
+## Test assertions
+
+openapi_first ships with a simple but powerful Test module to run request and response validation in your tests without using the middlewares. This is designed to be used with rack-test or Ruby on Rails integration tests or request specs.
+
+Here is how to set it up for Rails integration tests:
+
+```ruby
+# test_helper.rb
+require 'openapi_first/test'
+OpenapiFirst::Test.register('openapi/v1.openapi.yaml')
+```
+
+Inside your test:
+```ruby
+# test/integration/trips_api_test.rb
+require 'test_helper'
+
+class TripsApiTest < ActionDispatch::IntegrationTest
+  include OpenapiFirst::Test::Methods
+
+  test 'GET /trips' do
+    get '/trips',
+        params: { origin: 'efdbb9d1-02c2-4bc3-afb7-6788d8782b1e', destination: 'b2e783e1-c824-4d63-b37a-d8d698862f1d',
+                  date: '2024-07-02T09:00:00Z' }
+
+    assert_api_conform(status: 200)
+  end
+end
+```
 
 ## Manual use
 
@@ -159,23 +189,28 @@ definition = OpenapiFirst.load('openapi.yaml')
 ```ruby
 # Find and validate request
 rack_request = Rack::Request.new(env)
-request = definition.validate_request(rack_request)
+validated_request = definition.validate_request(rack_request)
 # Or raise an exception if validation fails:
-request = definition.validate_request(rack_request, raise_error: true) # Raises OpenapiFirst::RequestInvalidError or OpenapiFirst::NotFoundError if request is invalid
+definition.validate_request(rack_request, raise_error: true) # Raises OpenapiFirst::RequestInvalidError or OpenapiFirst::NotFoundError if request is invalid
 
 # Inspect the request and access parsed parameters
-request.known? # Is the request defined in the API description?
-request.valid? # => true / false
-request.error # => Failure object if request is invalid
-request.body # alias: parsed_body
-request.path_parameters # => { "pet_id" => 42 }
-request.query # alias: query_parameters
-request.params # Merged path and query parameters
-request.headers
-request.cookies
-request.content_type
-request.request_method # => "get"
-request.path # => "/pets/42"
+validated_request.known? # Is the request defined in the API description?
+validated_request.valid? # => true / false
+validated_request.invalid? # => true / false
+validated_request.error # => Failure object if request is invalid
+validated_request.parsed_params # Merged parsed path, query parameters and request body
+validated_request.parsed_body
+validated_request.parsed_path_parameters # => { "pet_id" => 42 }
+validated_request.parsed_headers
+validated_request.parsed_cookies
+validated_request.parsed_query
+
+# Access the Openapi 3 Operation Object Hash
+validated_request.operation['x-foo']
+validated_request.operation['operationId']
+# or the whole request definition
+validated_request.request_definition.path # => "/pets/{petId}"
+validated_request.request_definition.operation_id # => "showPetById"
 ```
 
 ### Validate response
@@ -183,21 +218,19 @@ request.path # => "/pets/42"
 ```ruby
 # Find and validate the response
 rack_response = Rack::Response[*app.call(env)]
-response = definition.validate_response(rack_request, rack_response)
+validated_response = definition.validate_response(rack_request, rack_response)
 
 # Raise an exception if validation fails:
-response = definition.validate_response(rack_request,rack_response, raise_error: true) # Raises OpenapiFirst::ResponseInvalidError or OpenapiFirst::ResponseNotFoundError
-# Or you can also call a method on the request object mentioned above
-request.validate_response(rack_response)
+definition.validate_response(rack_request,rack_response, raise_error: true) # Raises OpenapiFirst::ResponseInvalidError or OpenapiFirst::ResponseNotFoundError
 
 # Inspect the response and access parsed parameters and
 response.known? # Is the response defined in the API description?
 response.valid? # => true / false
+response.invalid? # => true / false
 response.error # => Failure object if response is invalid
-response.body
-request.headers
 response.status # => 200
-response.content_type
+response.parsed_body
+response.parsed_headers
 ```
 
 OpenapiFirst uses [`multi_json`](https://rubygems.org/gems/multi_json).
@@ -215,6 +248,50 @@ OpenapiFirst.configure do |config|
 end
 ```
 
+or configure per instance:
+
+```ruby
+OpenapiFirst.load('openapi.yaml') do |config|
+  config.request_validation_error_response = :jsonapi
+end
+```
+
+## Hooks
+
+You can integrate your code at certain points during request/response validation via hooks.
+
+Available hooks:
+
+- `after_request_validation`
+- `after_response_validation`
+- `after_request_parameter_property_validation`
+- `after_request_body_property_validation`
+
+Setup per per instance:
+
+```ruby
+OpenapiFirst.load('openapi.yaml') do |config|
+  config.after_request_validation do |validated_request|
+    validated_request.valid? # => true / false
+  end
+  config.after_response_validation do |validated_response, request|
+    if validated_response.invalid?
+      warn "#{request.request_method} #{request.path}: #{validated_response.error.message}"
+    end
+  end
+end
+```
+
+Setup globally:
+
+```ruby
+OpenapiFirst.configure do |config|
+  config.after_request_parameter_property_validation do |data, property, property_schema|
+    data[property] = Date.iso8601(data[property]) if propert_schema['format'] == 'date'
+  end
+end
+```
+
 ## Framework integration
 
 Using rack middlewares is supported in probably all Ruby web frameworks.

data/lib/openapi_first/body_parser.rb

@@ -5,30 +5,27 @@ require 'multi_json'
 module OpenapiFirst
   # @!visibility private
   class BodyParser
-    def self.const_missing(const_name)
-      super unless const_name == :ParsingError
-      warn 'DEPRECATION WARNING: OpenapiFirst::BodyParser::ParsingError is deprecated. ' \
-           'Use OpenapiFirst::ParseError instead.'
-      OpenapiFirst::ParseError
+    def initialize(content_type)
+      @is_json = :json if /json/i.match?(content_type)
     end
 
-    def parse(request, content_type)
+    def parse(request)
       body = read_body(request)
-      return if body.empty?
+      return if body.nil? || body.empty?
 
-      return MultiJson.load(body) if content_type =~ (/json/i) && (content_type =~ /json/i)
+      return MultiJson.load(body) if @is_json
       return request.POST if request.form_data?
 
       body
     rescue MultiJson::ParseError
-      raise ParseError, 'Failed to parse body as JSON'
+      Failure.fail!(:invalid_body, message: 'Failed to parse request body as JSON')
     end
 
     private
 
     def read_body(request)
-      body = request.body.read
-      request.body.rewind
+      body = request.body&.read
+      request.body.rewind if request.body.respond_to?(:rewind)
       body
     end
   end

data/lib/openapi_first/builder.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module OpenapiFirst
+  # Builds parts of a Definition
+  # This knows how to read a resolved OpenAPI document and build {Request} and {Response} objects.
+  class Builder
+    REQUEST_METHODS = %w[get head post put patch delete trace options].freeze
+
+    # Builds a router from a resolved OpenAPI document.
+    # @param resolved [Hash] The resolved OpenAPI document.
+    # @param config [OpenapiFirst::Configuration] The configuration object.
+    def self.build_router(resolved, config)
+      openapi_version = (resolved['openapi'] || resolved['swagger'])[0..2]
+      new(resolved, config, openapi_version).router
+    end
+
+    def initialize(resolved, config, openapi_version)
+      @resolved = resolved
+      @config = config
+      @openapi_version = openapi_version
+    end
+
+    attr_reader :resolved, :openapi_version, :config
+
+    def router # rubocop:disable Metrics/MethodLength
+      router = OpenapiFirst::Router.new
+      resolved['paths'].each do |path, path_item_object|
+        path_item_object.slice(*REQUEST_METHODS).keys.map do |request_method|
+          operation_object = path_item_object[request_method]
+          build_requests(path, request_method, operation_object, path_item_object).each do |request|
+            router.add_request(
+              request,
+              request_method:,
+              path:,
+              content_type: request.content_type
+            )
+          end
+          build_responses(operation_object).each do |response|
+            router.add_response(
+              response,
+              request_method:,
+              path:,
+              status: response.status,
+              response_content_type: response.content_type
+            )
+          end
+        end
+      end
+      router
+    end
+
+    def build_requests(path, request_method, operation_object, path_item_object)
+      hooks = config.hooks
+      path_item_parameters = path_item_object['parameters']
+      parameters = operation_object['parameters'].to_a.chain(path_item_parameters.to_a)
+      required_body = operation_object.dig('requestBody', 'required') == true
+      result = operation_object.dig('requestBody', 'content')&.map do |content_type, content|
+        Request.new(path:, request_method:, operation_object:, parameters:, content_type:,
+                    content_schema: content['schema'], required_body:, hooks:, openapi_version:)
+      end || []
+      return result if required_body
+
+      result << Request.new(
+        path:, request_method:, operation_object:,
+        parameters:, content_type: nil, content_schema: nil,
+        required_body:, hooks:, openapi_version:
+      )
+    end
+
+    def build_responses(operation_object)
+      Array(operation_object['responses']).flat_map do |status, response_object|
+        headers = response_object['headers']
+        response_object['content']&.map do |content_type, content_object|
+          content_schema = content_object['schema']
+          Response.new(status:, headers:, content_type:, content_schema:, openapi_version:)
+        end || Response.new(status:, headers:, content_type: nil,
+                            content_schema: nil, openapi_version:)
+      end
+    end
+  end
+end

data/lib/openapi_first/configuration.rb

@@ -3,17 +3,38 @@
 module OpenapiFirst
   # Global configuration. Currently only used for the request validation middleware.
   class Configuration
+    HOOKS = %i[
+      after_request_validation
+      after_response_validation
+      after_request_parameter_property_validation
+      after_request_body_property_validation
+    ].freeze
+
     def initialize
-      @request_validation_error_response = OpenapiFirst.find_plugin(:default)::ErrorResponse
+      @request_validation_error_response = OpenapiFirst.find_error_response(:default)
       @request_validation_raise_error = false
+      @response_validation_raise_error = true
+      @hooks = (HOOKS.map { [_1, []] }).to_h
     end
 
-    attr_reader :request_validation_error_response
-    attr_accessor :request_validation_raise_error
+    attr_reader :request_validation_error_response, :hooks
+    attr_accessor :request_validation_raise_error, :response_validation_raise_error
+
+    def clone
+      copy = super
+      copy.instance_variable_set(:@hooks, @hooks&.transform_values(&:clone))
+      copy
+    end
+
+    HOOKS.each do |hook|
+      define_method(hook) do |&block|
+        hooks[hook] << block
+      end
+    end
 
     def request_validation_error_response=(mod)
       @request_validation_error_response = if mod.is_a?(Symbol)
-                                             OpenapiFirst.find_plugin(:default)::ErrorResponse
+                                             OpenapiFirst.find_error_response(mod)
                                            else
                                              mod
                                            end

data/lib/openapi_first/definition.rb

@@ -1,125 +1,69 @@
 # frozen_string_literal: true
 
-require_relative 'definition/path_item'
-require_relative 'runtime_request'
-require_relative 'request_validation/validator'
-require_relative 'response_validation/validator'
+require_relative 'failure'
+require_relative 'router'
+require_relative 'request'
+require_relative 'response'
+require_relative 'builder'
 
 module OpenapiFirst
   # Represents an OpenAPI API Description document
   # This is returned by OpenapiFirst.load.
   class Definition
-    attr_reader :filepath, :paths, :openapi_version
+    attr_reader :filepath, :config, :paths, :router
 
     # @param resolved [Hash] The resolved OpenAPI document.
     # @param filepath [String] The file path of the OpenAPI document.
     def initialize(resolved, filepath = nil)
       @filepath = filepath
-      @paths = resolved['paths']
-      @openapi_version = detect_version(resolved)
+      @config = OpenapiFirst.configuration.clone
+      yield @config if block_given?
+      @config.freeze
+      @router = Builder.build_router(resolved, @config)
+      @paths = resolved['paths'].keys # TODO: Move into builder as well
+    end
+
+    def routes
+      @router.routes
     end
 
     # Validates the request against the API description.
-    # @param rack_request [Rack::Request] The Rack request object.
-    # @param raise_error [Boolean] Whether to raise an error if validation fails.
-    # @return [RuntimeRequest] The validated request object.
-    def validate_request(rack_request, raise_error: false)
-      runtime_request = request(rack_request)
-      validator = RequestValidation::Validator.new(runtime_request.operation)
-      validation_error = validator.validate(runtime_request)
-      validation_error.raise! if validation_error && raise_error
-      runtime_request.error = validation_error
-      runtime_request
+    # @param [Rack::Request] rack_request The Rack request object.
+    # @param [Boolean] raise_error Whether to raise an error if validation fails.
+    # @return [ValidatedRequest] The validated request object.
+    def validate_request(request, raise_error: false)
+      route = @router.match(request.request_method, request.path, content_type: request.content_type)
+      validated = if route.error
+                    ValidatedRequest.new(request, error: route.error)
+                  else
+                    route.request_definition.validate(request, route_params: route.params)
+                  end
+      @config.hooks[:after_request_validation].each { |hook| hook.call(validated, self) }
+      raise validated.error.exception(validated) if validated.error && raise_error
+
+      validated
     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] Whether to raise an error if validation fails.
-    # @return [RuntimeResponse] The validated response object.
+    # @return [ValidatedResponse] The validated response object.
     def validate_response(rack_request, rack_response, raise_error: false)
-      runtime_response = response(rack_request, rack_response)
-      validator = ResponseValidation::Validator.new(runtime_response.operation)
-      validation_error = validator.validate(runtime_response)
-      validation_error.raise! if validation_error && raise_error
-      runtime_response.error = validation_error
-      runtime_response
-    end
-
-    # Builds a RuntimeRequest object based on the Rack request.
-    # @param rack_request [Rack::Request] The Rack request object.
-    # @return [RuntimeRequest] The RuntimeRequest object.
-    def request(rack_request)
-      path_item, path_params = find_path_item_and_params(rack_request.path)
-      operation = path_item&.operation(rack_request.request_method.downcase)
-      RuntimeRequest.new(
-        request: rack_request,
-        path_item:,
-        operation:,
-        path_params:
-      )
-    end
-
-    # Builds a RuntimeResponse object based on the Rack request and response.
-    # @param rack_request [Rack::Request] The Rack request object.
-    # @param rack_response [Rack::Response] The Rack response object.
-    # @return [RuntimeResponse] The RuntimeResponse object.
-    def response(rack_request, rack_response)
-      runtime_request = request(rack_request)
-      RuntimeResponse.new(runtime_request.operation, rack_response)
-    end
-
-    # Gets all the operations defined in the API description.
-    # @return [Array<Operation>] An array of Operation objects.
-    def operations
-      @operations ||= path_items.flat_map(&:operations)
-    end
-
-    # Gets the PathItem object for the specified path.
-    # @param pathname [String] The path template string.
-    # @return [PathItem] The PathItem object.
-    # Example:
-    #   definition.path('/pets/{id}')
-    def path(pathname)
-      return unless paths.key?(pathname)
-
-      PathItem.new(pathname, paths[pathname], openapi_version:)
-    end
-
-    private
-
-    # Gets all the PathItem objects defined in the API description.
-    # @return [Array] An array of PathItem objects.
-    def path_items
-      @path_items ||= paths.flat_map do |path, path_item_object|
-        PathItem.new(path, path_item_object, openapi_version:)
-      end
-    end
-
-    def find_path_item_and_params(request_path)
-      if paths.key?(request_path)
-        return [
-          PathItem.new(request_path, paths[request_path], openapi_version:),
-          {}
-        ]
-      end
-      search_for_path_item(request_path)
-    end
-
-    def search_for_path_item(request_path)
-      path_items.find do |path_item|
-        path_params = path_item.match(request_path)
-        next unless path_params
-
-        return [
-          path_item,
-          path_params
-        ]
-      end
-    end
-
-    def detect_version(resolved)
-      (resolved['openapi'] || resolved['swagger'])[0..2]
+      route = @router.match(rack_request.request_method, rack_request.path, content_type: rack_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)
+      error = response_match.error
+      validated = if error
+                    ValidatedResponse.new(rack_response, error:)
+                  else
+                    response_match.response.validate(rack_response)
+                  end
+      @config.hooks[:after_response_validation]&.each { |hook| hook.call(validated, rack_request, self) }
+      raise validated.error.exception(validated) if raise_error && validated.invalid?
+
+      validated
     end
   end
 end

data/lib/openapi_first/error_response.rb

@@ -12,12 +12,12 @@ module OpenapiFirst
 
     # The response body
     def body
-      raise NotImplementedError
+      raise "#{self.class} must implement the method #{__method__}"
     end
 
     # The response content-type
     def content_type
-      raise NotImplementedError
+      raise "#{self.class} must implement the method #{__method__}"
     end
 
     STATUS = {