openapi_first 2.5.1 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf125609ca3acdca953b0ab241990d7593ac3ac1820e4dcda0b1f7f711cfd87b
-  data.tar.gz: 53c2039f9fb7f379784f08f2dbcf7e3aac3273f7cd452af17227ccb2b896ed9e
+  metadata.gz: 63630ef9a08bcbb2602c05d518f0fc8e2da334ca27e8b5aa06d1165e16c5b1f8
+  data.tar.gz: 7a78262f72e78437b873a2044c81dac22fd76befa8671f457bf0deebe523028e
 SHA512:
-  metadata.gz: 89f5dce609ef24d0ef739b887e42604784e7849395c967bce6f4f79084d5e35ef9f63608c3c328dc5825ffb668cc68c934290195f20edb8ace5bbf6d6adb6e26
-  data.tar.gz: 9716f7808d362cec5e6261abc67c05082a7a6b997eed96a3e74b9e58172579f2f8a80464b20699b8f8a5c8d875d1cb3eaee57bf6300d971b6ad9bc6484f8d04b
+  metadata.gz: cd59bdb56d8ff90378967cf410ad0ccf0583d69b56bc153bc454773e2637023efb420658b7ba8e71ada6e763d116727b4057e73f6664b0ce2216127759e0aac7
+  data.tar.gz: 128c890b985671e5f882cb58bc0e5fbe49098619321d420d52d49035ad2650b18cc65b9cde246247a21176db23de527aec8b2e7921b693c638297d5057f63802

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## Unreleased
 
+## 2.6.0
+
+- Middlewares now accept the OAD as a first positional argument instead of `:spec` inside the options hash.
+- No longer merge parameter schemas of the same location (for example "query") in order to fix [#320](https://github.com/ahx/openapi_first/issues/320). Use `OpenapiFirst::Schema::Hash` to validate multiple parameters schemas and return a single error object.
+- `OpenapiFirst::Test::Methods[MyApplication]` returns a Module which adds an `app` method to be used by rack-test alonside the `assert_api_conform` method.
+- Make default coverage report less verbose
+  The default formatter (TerminalFormatter) no longer prints all un-requested requests by default. You can set `test.coverage_formatter_options = { focused: false }` to get back the old behavior
+
 ## 2.5.1
 
 - Fix skipping skipped responses during coverage tracking

data/README.md

@@ -136,35 +136,41 @@ If you are adopting OpenAPI you can use these options together with [hooks](#hoo
 
 ## Contract Testing
 
+Here are two aspects of contract testing: Validation and Coverage
+
+### Validation
+
+By validating requests and responses, you can avoid that your API implementation processes requests or returns responses that don't match your API description. You can use [test assertions](#test-assertions) or [rack middlewares](#rack-middlewares) or manual validation to validate requests and responses with openapi_first.
+
 ### Coverage
 
+To make sure your _whole_ API description is implemented, openapi_first ships with a coverage feature.
+
 > [!NOTE]
 > This is a brand new feature. ✨ Your feedback is very welcome.
 
-This feature tracks all requests/resposes that are validated via openapi_first and get return an overal coverage value. If all of your described requests/responses have been validated successfully at least once, your coverage is 100%.
-By checking your validation coverage you can avoid API drift where your API description describes requests/responses differently than your implemention works.
-
-Here is how to set it up for RSpec in your `spec/spec_helper.rb`:
+This feature tracks all requests/resposes that are validated via openapi_first and tells you about which request/responses are missing.
+Here is how to set it up with [rack-test](https://github.com/rack/rack-test):
 
-1. Register all OpenAPI documents to track coverage for and start tracking. This should go at the top of you test helper file before loading application code.
+1. Register all OpenAPI documents to track coverage for. This should go at the top of your test helper file before loading your application code.
   ```ruby
   require 'openapi_first'
   OpenapiFirst::Test.setup do |s|
     test.register('openapi/openapi.yaml')
-    test.minimum_coverage = 100 # Setting this will lead to an `exit 2` if coverage is below minimum
-    test.skip_response_coverage { it.status == '500' }
+    test.minimum_coverage = 100 # (Optional) Setting this will lead to an `exit 2` if coverage is below minimum
+    test.skip_response_coverage { it.status == '500' } # (Optional) Skip certain responses
   end
   ```
-2. Wrap your app with silent request / response validation. This validates all requets/responses you do during your test run. (✷1)
+2. Add an `app` method to your tests, which wraps your application with silent request / response validation. This validates all requests/responses in your test run. (✷1)
+
   ```ruby
-  config.before type: :request do
-    def app
-      OpenapiFirst::Test.app(App)
-    end
+  def app
+    OpenapiFirst::Test.app(MyApp)
   end
   ```
+3. Run your tests.  The Coverage feature will tell you about missing request/responses. 
 
-(✷1): Instead of using `OpenapiFirstTest.app` to wrap your application, you can use the middlewares or [test assertion method](#test-assertions), but you would have to do that for all requests/responses defined in your API description to make coverage work.
+(✷1): It does not matter what method of openapi_first you use to validate requests/responses. Instead of using `OpenapiFirstTest.app` to wrap your application, you could also use the middlewares or [test assertion method](#test-assertions), but you would have to do that for all requests/responses defined in your API description to make coverage work.
 
 ### Test assertions
 
@@ -306,6 +312,10 @@ end
 Using rack middlewares is supported in probably all Ruby web frameworks.
 If you are using Ruby on Rails for example, you can add the request validation middleware globally in `config/application.rb` or inside specific controllers.
 
+The contract testing feature is designed to be used via rack-test, which should be compatible all Ruby web frameworks as well.
+
+That aside, closer integration with specific frameworks like Sinatra, Hanami, Roda or Rails would be great. If you have ideas, pain points or PRs, please don't hesitate to [share](https://github.com/ahx/openapi_first/discussions).
+
 ## Alternatives
 
 This gem was inspired by [committe](https://github.com/interagent/committee) (Ruby) and [Connexion](https://github.com/spec-first/connexion) (Python).

data/lib/openapi_first/builder.rb

@@ -1,6 +1,13 @@
 # frozen_string_literal: true
 
 require 'json_schemer'
+
+require_relative 'failure'
+require_relative 'router'
+require_relative 'header'
+require_relative 'request'
+require_relative 'response'
+require_relative 'schema/hash'
 require_relative 'ref_resolver'
 
 module OpenapiFirst
@@ -17,10 +24,8 @@ module OpenapiFirst
     end
 
     def initialize(contents, filepath:, config:)
-      @schemer_configuration = JSONSchemer.configuration.clone
-      @schemer_configuration.meta_schema = detect_meta_schema(contents, filepath)
-      @schemer_configuration.insert_property_defaults = true
-
+      meta_schema = detect_meta_schema(contents, filepath)
+      @schemer_configuration = build_schemer_config(filepath:, meta_schema:)
       @config = config
       @contents = RefResolver.for(contents, filepath:)
     end
@@ -28,6 +33,18 @@ module OpenapiFirst
     attr_reader :config
     private attr_reader :schemer_configuration
 
+    def build_schemer_config(filepath:, meta_schema:)
+      result = JSONSchemer.configuration.clone
+      dir = (filepath && File.absolute_path(File.dirname(filepath))) || Dir.pwd
+      result.base_uri = URI::File.build({ path: "#{dir}/" })
+      result.ref_resolver = JSONSchemer::CachedResolver.new do |uri|
+        FileLoader.load(uri.path)
+      end
+      result.meta_schema = meta_schema
+      result.insert_property_defaults = true
+      result
+    end
+
     def detect_meta_schema(document, filepath)
       # Copied from JSONSchemer 🙇🏻‍♂️
       version = document['openapi']
@@ -46,10 +63,10 @@ module OpenapiFirst
     def router # rubocop:disable Metrics/MethodLength
       router = OpenapiFirst::Router.new
       @contents.fetch('paths').each do |path, path_item_object|
-        path_parameters = resolve_parameters(path_item_object['parameters'])
+        path_parameters = path_item_object['parameters'] || []
         path_item_object.resolved.keys.intersection(REQUEST_METHODS).map do |request_method|
           operation_object = path_item_object[request_method]
-          operation_parameters = resolve_parameters(operation_object['parameters'])
+          operation_parameters = operation_object['parameters'] || []
           parameters = parse_parameters(operation_parameters.chain(path_parameters))
 
           build_requests(path:, request_method:, operation_object:,
@@ -79,10 +96,10 @@ module OpenapiFirst
     def parse_parameters(parameters)
       grouped_parameters = group_parameters(parameters)
       ParsedParameters.new(
-        query: grouped_parameters[:query],
-        path: grouped_parameters[:path],
-        cookie: grouped_parameters[:cookie],
-        header: grouped_parameters[:header],
+        query: resolve_parameters(grouped_parameters[:query]),
+        path: resolve_parameters(grouped_parameters[:path]),
+        cookie: resolve_parameters(grouped_parameters[:cookie]),
+        header: resolve_parameters(grouped_parameters[:header]),
         query_schema: build_parameter_schema(grouped_parameters[:query]),
         path_schema: build_parameter_schema(grouped_parameters[:path]),
         cookie_schema: build_parameter_schema(grouped_parameters[:cookie]),
@@ -99,11 +116,18 @@ module OpenapiFirst
     end
 
     def build_parameter_schema(parameters)
-      schema = build_parameters_schema(parameters)
+      return unless parameters
 
-      JSONSchemer.schema(schema,
-                         configuration: schemer_configuration,
-                         after_property_validation: config.hooks[:after_request_parameter_property_validation])
+      required = []
+      schemas = parameters.each_with_object({}) do |parameter, result|
+        schema = parameter['schema'].schema(configuration: schemer_configuration)
+        name = parameter['name']&.value
+        required << name if parameter['required']&.value
+        result[name] = schema if schema
+      end
+
+      Schema::Hash.new(schemas, required:, configuration: schemer_configuration,
+                                after_property_validation: config.hooks[:after_request_parameter_property_validation])
     end
 
     def build_requests(path:, request_method:, operation_object:, parameters:)
@@ -141,20 +165,15 @@ module OpenapiFirst
       return [] unless responses
 
       responses.flat_map do |status, response_object|
-        headers = response_object['headers']&.resolved
-        headers_schema = JSONSchemer::Schema.new(
-          build_headers_schema(headers),
-          configuration: schemer_configuration
-        )
+        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)
           Response.new(status:,
                        headers:,
-                       headers_schema:,
                        content_type:,
                        content_schema:,
                        key: [request.key, status, content_type].join(':'))
-        end || Response.new(status:, headers:, headers_schema:, content_type: nil,
+        end || Response.new(status:, headers:, content_type: nil,
                             content_schema: nil, key: [request.key, status, nil].join(':'))
       end
     end
@@ -162,49 +181,32 @@ module OpenapiFirst
     IGNORED_HEADER_PARAMETERS = Set['Content-Type', 'Accept', 'Authorization'].freeze
     private_constant :IGNORED_HEADER_PARAMETERS
 
-    def group_parameters(parameter_definitions)
-      result = {}
-      parameter_definitions&.each do |parameter|
-        (result[parameter['in'].to_sym] ||= []) << parameter
-      end
-      result[:header]&.reject! { IGNORED_HEADER_PARAMETERS.include?(_1['name']) }
-      result
-    end
-
-    def build_headers_schema(headers_object)
-      return unless headers_object&.any?
+    def build_response_headers(headers_object)
+      return if headers_object.nil?
 
-      properties = {}
-      required = []
+      result = []
       headers_object.each do |name, header|
-        schema = header['schema']
-        next if name.casecmp('content-type').zero?
-
-        properties[name] = schema if schema
-        required << name if header['required']
+        next if header['schema'].nil?
+        next if IGNORED_HEADER_PARAMETERS.include?(name)
+
+        header = Header.new(
+          name:,
+          schema: header['schema'].schema(configuration: schemer_configuration),
+          required?: header['required']&.value == true,
+          node: header
+        )
+        result << header
       end
-      {
-        'properties' => properties,
-        'required' => required
-      }
+      result
     end
 
-    def build_parameters_schema(parameters)
-      return unless parameters
-
-      properties = {}
-      required = []
-      parameters.each do |parameter|
-        schema = parameter['schema']
-        name = parameter['name']
-        properties[name] = schema if schema
-        required << name if parameter['required']
+    def group_parameters(parameter_definitions)
+      result = {}
+      parameter_definitions&.each do |parameter|
+        (result[parameter['in']&.value&.to_sym] ||= []) << parameter
       end
-
-      {
-        'properties' => properties,
-        'required' => required
-      }
+      result[:header]&.reject! { IGNORED_HEADER_PARAMETERS.include?(_1['name']&.value) }
+      result
     end
 
     ParsedParameters = Data.define(:path, :query, :header, :cookie, :path_schema, :query_schema, :header_schema,

data/lib/openapi_first/definition.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'failure'
-require_relative 'router'
-require_relative 'request'
-require_relative 'response'
 require_relative 'builder'
 require 'forwardable'
 

data/lib/openapi_first/header.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module OpenapiFirst
+  Header = Data.define(:name, :required?, :schema, :node) do
+    def resolved_schema
+      node['schema']&.resolved
+    end
+  end
+end

data/lib/openapi_first/middlewares/request_validation.rb

@@ -6,19 +6,26 @@ module OpenapiFirst
     # A Rack middleware to validate requests against an OpenAPI API description
     class RequestValidation
       # @param app The parent Rack application
-      # @param options An optional Hash of configuration options to override defaults
+      # @param spec [String, OpenapiFirst::Definition] Path to the OpenAPI file or an instance of Definition.
+      # @param options Hash
+      #   :spec [String, OpenapiFirst::Definition] Path to the OpenAPI file or an instance of Definition.
+      #         This will be deprecated. Please use spec argument instead.
       #   :raise_error    A Boolean indicating whether to raise an error if validation fails.
       #                   default: false
       #   :error_response The Class to use for error responses.
       #                   This can be a Symbol-name of an registered error response (:default, :jsonapi)
       #                   or it can be set to false to disable returning a response.
       #                   default: OpenapiFirst::Plugins::Default::ErrorResponse (Config.default_options.error_response)
-      def initialize(app, options = {})
+      def initialize(app, spec = nil, options = {})
         @app = app
+        if spec.is_a?(Hash)
+          options = spec
+          spec = options.fetch(:spec)
+        end
         @raise = options.fetch(:raise_error, OpenapiFirst.configuration.request_validation_raise_error)
         @error_response_class = error_response_option(options[:error_response])
 
-        spec = options.fetch(:spec)
+        spec ||= options.fetch(:spec)
         raise "You have to pass spec: when initializing #{self.class}" unless spec
 
         @definition = spec.is_a?(Definition) ? spec : OpenapiFirst.load(spec)

data/lib/openapi_first/middlewares/response_validation.rb

@@ -6,15 +6,19 @@ module OpenapiFirst
   module Middlewares
     # A Rack middleware to validate requests against an OpenAPI API description
     class ResponseValidation
-      # @param app The parent Rack application
+      # @param spec [String, OpenapiFirst::Definition] Path to the OpenAPI file or an instance of Definition
       # @param options Hash
-      #   :spec [String, OpenapiFirst::Definition] Path to the OpenAPI file or an instance of Definition
+      #   :spec [String, OpenapiFirst::Definition] Path to the OpenAPI file or an instance of Definition.
+      #         This will be deprecated. Please use spec argument instead.
       #   :raise_error [Boolean] Whether to raise an error if validation fails. default: true
-      def initialize(app, options = {})
+      def initialize(app, spec = nil, options = {})
         @app = app
+        if spec.is_a?(Hash)
+          options = spec
+          spec = options.fetch(:spec)
+        end
         @raise = options.fetch(:raise_error, OpenapiFirst.configuration.response_validation_raise_error)
 
-        spec = options.fetch(:spec)
         raise "You have to pass spec: when initializing #{self.class}" unless spec
 
         @definition = spec.is_a?(Definition) ? spec : OpenapiFirst.load(spec)
@@ -25,7 +29,8 @@ module OpenapiFirst
 
       def call(env)
         status, headers, body = @app.call(env)
-        @definition.validate_response(Rack::Request.new(env), Rack::Response[status, headers, body], raise_error: @raise)
+        @definition.validate_response(Rack::Request.new(env), Rack::Response[status, headers, body],
+                                      raise_error: @raise)
         [status, headers, body]
       end
     end

data/lib/openapi_first/ref_resolver.rb

@@ -41,8 +41,11 @@ module OpenapiFirst
         @value = value
         @context = context
         @filepath = filepath
-        dir = File.dirname(File.expand_path(filepath)) if filepath
-        @dir = (dir && File.absolute_path(dir)) || Dir.pwd
+        @dir = if filepath
+                 File.dirname(File.absolute_path(filepath))
+               else
+                 Dir.pwd
+               end
       end
 
       # The value of this node
@@ -52,7 +55,11 @@ module OpenapiFirst
       # The object where this node was found in
       attr_reader :context
 
-      private attr_reader :filepath
+      attr_reader :filepath
+
+      def ==(_other)
+        raise "Don't call == on an unresolved value. Use .value == other instead."
+      end
 
       def resolve_ref(pointer)
         if pointer.start_with?('#')
@@ -89,6 +96,10 @@ module OpenapiFirst
       include Diggable
       include Enumerable
 
+      def ==(_other)
+        raise "Don't call == on an unresolved value. Use .value == other instead."
+      end
+
       def resolved
         return resolve_ref(value['$ref']).value if value.key?('$ref')
 
@@ -108,17 +119,16 @@ module OpenapiFirst
       end
 
       def each
-        resolved.each do |key, value|
-          yield key, RefResolver.for(value, filepath:, context:)
+        resolved.each_key do |key|
+          yield key, self[key]
         end
       end
 
-      def schema(options = {})
-        ref_resolver = JSONSchemer::CachedResolver.new do |uri|
-          FileLoader.load(uri.path)
-        end
+      # You have to pass configuration or ref_resolver
+      def schema(options)
         base_uri = URI::File.build({ path: "#{dir}/" })
-        root = JSONSchemer::Schema.new(context, base_uri:, ref_resolver:, **options)
+        root = JSONSchemer::Schema.new(context, base_uri:, **options)
+        # binding.irb if value['maxItems'] == 4
         JSONSchemer::Schema.new(value, nil, root, base_uri:, **options)
       end
     end
@@ -137,8 +147,8 @@ module OpenapiFirst
       end
 
       def each
-        resolved.each do |item|
-          yield RefResolver.for(item, filepath:, context:)
+        resolved.each_with_index do |_item, index|
+          yield self[index]
         end
       end
 

data/lib/openapi_first/response.rb

@@ -9,21 +9,20 @@ module OpenapiFirst
   # This is not a direct reflecton of the OpenAPI 3.X response definition, but a combination of
   # status, content type and content schema.
   class Response
-    def initialize(status:, headers:, headers_schema:, content_type:, content_schema:, key:)
+    def initialize(status:, headers:, content_type:, content_schema:, key:)
       @status = status
       @content_type = content_type
       @content_schema = content_schema
       @headers = headers
-      @headers_schema = headers_schema
       @key = key
       @parser = ResponseParser.new(headers:, content_type:)
-      @validator = ResponseValidator.new(self)
+      @validator = ResponseValidator.new(content_schema:, headers:)
     end
 
     # @attr_reader [Integer] status The HTTP status code of the response definition.
     # @attr_reader [String, nil] content_type Content type of this response.
     # @attr_reader [Schema, nil] content_schema the Schema of the response body.
-    attr_reader :status, :content_type, :content_schema, :headers, :headers_schema, :key
+    attr_reader :status, :content_type, :content_schema, :headers, :key
 
     def validate(response)
       parsed_values = nil

data/lib/openapi_first/response_parser.rb

@@ -15,7 +15,7 @@ module OpenapiFirst
     def parse(rack_response)
       ParsedResponse.new(
         body: @body_parser.call(read_body(rack_response)),
-        headers: @headers_parser.call(rack_response.headers)
+        headers: @headers_parser&.call(rack_response.headers) || {}
       )
     end
 
@@ -30,9 +30,16 @@ module OpenapiFirst
       rack_response.body
     end
 
-    def build_headers_parser(header_definitions)
-      headers_as_parameters = header_definitions.to_a.map do |name, definition|
-        definition.merge('name' => name, 'in' => 'header')
+    def build_headers_parser(headers)
+      return unless headers&.any?
+
+      headers_as_parameters = headers.map do |header|
+        {
+          'name' => header.name,
+          'explode' => false,
+          'in' => 'header',
+          'schema' => header.resolved_schema
+        }
       end
       OpenapiParameters::Header.new(headers_as_parameters).method(:unpack)
     end

data/lib/openapi_first/response_validator.rb

@@ -11,10 +11,10 @@ module OpenapiFirst
       Validators::ResponseBody
     ].freeze
 
-    def initialize(response_definition)
-      @validators = VALIDATORS.filter_map do |klass|
-        klass.for(response_definition)
-      end
+    def initialize(content_schema:, headers:)
+      @validators = []
+      @validators << Validators::ResponseBody.new(content_schema) if content_schema
+      @validators << Validators::ResponseHeaders.new(headers) if headers&.any?
     end
 
     def call(parsed_response)

data/lib/openapi_first/schema/hash.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'validation_error'
+
+module OpenapiFirst
+  class Schema
+    # A hash of Schemas
+    class Hash
+      # @param schema Hash of schemas
+      # @param required Array of required keys
+      def initialize(schemas, required: nil, **options)
+        @schemas = schemas
+        @options = options
+        @after_property_validation = options.delete(:after_property_validation)
+        schema = { 'type' => 'object' }
+        schema['required'] = required if required
+        @root_schema = JSONSchemer.schema(schema, **options)
+      end
+
+      def validate(root_value)
+        validation = @root_schema.validate(root_value)
+        validations = @schemas.reduce(validation) do |enum, (key, schema)|
+          root_value[key] = schema.value['default'] if schema.value.key?('default') && !root_value.key?(key)
+          next enum unless root_value.key?(key)
+
+          value = root_value[key]
+          key_validation = schema.validate(value)
+          @after_property_validation&.each do |hook|
+            hook.call(root_value, key, schema.value, nil)
+          end
+          enum.chain(key_validation.map do |err|
+            data_pointer = "/#{key}"
+            err.merge(
+              'error' => JSONSchemer::Errors.pretty(err),
+              'data_pointer' => data_pointer
+            )
+          end)
+        end
+        ValidationResult.new(validations)
+      end
+    end
+  end
+end

data/lib/openapi_first/schema/validation_error.rb

@@ -3,7 +3,44 @@
 module OpenapiFirst
   class Schema
     # One of multiple validation errors. Returned by Schema::ValidationResult#errors.
-    ValidationError = Data.define(:value, :message, :data_pointer, :schema_pointer, :type, :details, :schema) do
+    ValidationError = Data.define(:value, :data_pointer, :schema_pointer, :type, :details, :schema) do
+      # This returns an error message for this specific error.
+      # This it copied from json_schemer here to be easier to customize when passing custom data_pointers.
+      def message
+        location = data_pointer.empty? ? 'root' : "`#{data_pointer}`"
+
+        case type
+        when 'required'
+          keys = details.fetch('missing_keys', []).join(', ')
+          "object at #{location} is missing required properties: #{keys}"
+        when 'dependentRequired'
+          keys = details.fetch('missing_keys').join(', ')
+          "object at #{location} is missing required properties: #{keys}"
+        when 'string', 'boolean', 'number'
+          "value at #{location} is not a #{type}"
+        when 'array', 'object', 'integer'
+          "value at #{location} is not an #{type}"
+        when 'null'
+          "value at #{location} is not #{type}"
+        when 'pattern'
+          "string at #{location} does not match pattern: #{schema.fetch('pattern')}"
+        when 'format'
+          "value at #{location} does not match format: #{schema.fetch('format')}"
+        when 'const'
+          "value at #{location} is not: #{schema.fetch('const').inspect}"
+        when 'enum'
+          "value at #{location} is not one of: #{schema.fetch('enum')}"
+        when 'minimum'
+          "number at #{location} is less than: #{schema['minimum']}"
+        when 'maximum'
+          "number at #{location} is greater than: #{schema['maximum']}"
+        when 'readOnly'
+          "value at #{location} is `readOnly`"
+        else
+          "value at #{location} is invalid (#{type.inspect})"
+        end
+      end
+
       # @deprecated Please use {#message} instead
       def error
         warn 'OpenapiFirst::Schema::ValidationError#error is deprecated. Use #message instead.'

data/lib/openapi_first/schema/validation_result.rb

@@ -17,7 +17,6 @@ module OpenapiFirst
         @errors ||= @validation.map do |err|
           ValidationError.new(
             value: err['data'],
-            message: err['error'],
             data_pointer: err['data_pointer'],
             schema_pointer: err['schema_pointer'],
             type: err['type'],

data/lib/openapi_first/test/coverage/terminal_formatter.rb

@@ -5,8 +5,9 @@ module OpenapiFirst
     module Coverage
       # This is the default formatter
       class TerminalFormatter
-        def initialize(verbose: false)
+        def initialize(verbose: false, focused: true)
           @verbose = verbose
+          @focused = focused && !verbose
         end
 
         # This takes a list of Coverage::Plan instances and outputs a String
@@ -16,7 +17,7 @@ module OpenapiFirst
           @out.string
         end
 
-        private attr_reader :out, :verbose
+        private attr_reader :out, :verbose, :focused
 
         private
 
@@ -36,8 +37,9 @@ module OpenapiFirst
           plan.routes.each do |route|
             next if route.finished? && !verbose
 
+            next if route.requests.none?(&:requested?) && focused
+
             format_requests(route.requests)
-            next if route.requests.none?(&:requested?)
 
             format_responses(route.responses)
           end

data/lib/openapi_first/test/methods.rb

@@ -7,6 +7,16 @@ module OpenapiFirst
   module Test
     # Methods to use in integration tests
     module Methods
+      def self.[](*)
+        mod = Module.new do
+          def self.included(base)
+            OpenapiFirst::Test::Methods.included(base)
+          end
+        end
+        mod.define_method(:app) { OpenapiFirst::Test.app(*) }
+        mod
+      end
+
       def self.included(base)
         if Test.minitest?(base)
           base.include(OpenapiFirst::Test::MinitestHelpers)

data/lib/openapi_first/test.rb

@@ -81,7 +81,6 @@ module OpenapiFirst
     def self.report_coverage(formatter: Coverage::TerminalFormatter, **)
       coverage_result = Coverage.result
       puts formatter.new(**).format(coverage_result)
-      puts "The overal API validation coverage of this run is: #{coverage_result.coverage}%"
     end
 
     # Returns the Rack app wrapped with silent request, response validation

data/lib/openapi_first/validators/request_parameters.rb

@@ -6,7 +6,6 @@ module OpenapiFirst
       RequestHeaders = Data.define(:schema) do
         def call(parsed_request)
           validation = schema.validate(parsed_request.headers)
-          validation = Schema::ValidationResult.new(validation.to_a)
           Failure.fail!(:invalid_header, errors: validation.errors) if validation.error?
         end
       end
@@ -14,7 +13,6 @@ module OpenapiFirst
       Path = Data.define(:schema) do
         def call(parsed_request)
           validation = schema.validate(parsed_request.path)
-          validation = Schema::ValidationResult.new(validation.to_a)
           Failure.fail!(:invalid_path, errors: validation.errors) if validation.error?
         end
       end
@@ -22,7 +20,6 @@ module OpenapiFirst
       Query = Data.define(:schema) do
         def call(parsed_request)
           validation = schema.validate(parsed_request.query)
-          validation = Schema::ValidationResult.new(validation.to_a)
           Failure.fail!(:invalid_query, errors: validation.errors) if validation.error?
         end
       end
@@ -30,7 +27,6 @@ module OpenapiFirst
       RequestCookies = Data.define(:schema) do
         def call(parsed_request)
           validation = schema.validate(parsed_request.cookies)
-          validation = Schema::ValidationResult.new(validation.to_a)
           Failure.fail!(:invalid_cookie, errors: validation.errors) if validation.error?
         end
       end
@@ -45,7 +41,7 @@ module OpenapiFirst
       def self.for(args)
         VALIDATORS.filter_map do |key, klass|
           schema = args[key]
-          klass.new(schema) if schema.value
+          klass.new(schema) if schema
         end
       end
     end

data/lib/openapi_first/validators/response_body.rb

@@ -5,13 +5,6 @@ require_relative '../schema/validation_result'
 module OpenapiFirst
   module Validators
     class ResponseBody
-      def self.for(response_definition)
-        schema = response_definition&.content_schema
-        return unless schema
-
-        new(schema)
-      end
-
       def initialize(schema)
         @schema = schema
       end

data/lib/openapi_first/validators/response_headers.rb

@@ -3,24 +3,37 @@
 module OpenapiFirst
   module Validators
     class ResponseHeaders
-      def self.for(response_definition)
-        schema = response_definition&.headers_schema
-        return unless schema&.value
-
-        new(schema)
+      def initialize(headers)
+        @headers = headers
       end
 
-      def initialize(schema)
-        @schema = schema
+      attr_reader :headers
+
+      def call(parsed_response)
+        headers.each do |header|
+          header_value = parsed_response.headers[header.name]
+          next if header_value.nil? && !header.required?
+
+          validation_errors = header.schema.validate(header_value)
+          next unless validation_errors.any?
+
+          Failure.fail!(:invalid_response_header,
+                        errors: [error_for(data_pointer: "/#{header.name}", value: header_value,
+                                           error: validation_errors.first)])
+        end
       end
 
-      attr_reader :schema
+      private
 
-      def call(parsed_request)
-        validation = Schema::ValidationResult.new(
-          schema.validate(parsed_request.headers)
+      def error_for(data_pointer:, value:, error:)
+        Schema::ValidationError.new(
+          value: value,
+          data_pointer:,
+          schema_pointer: error['schema_pointer'],
+          type: error['type'],
+          details: error['details'],
+          schema: error['schema']
         )
-        Failure.fail!(:invalid_response_header, errors: validation.errors) if validation.error?
       end
     end
   end

data/lib/openapi_first/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: openapi_first
 version: !ruby/object:Gem::Version
-  version: 2.5.1
+  version: 2.6.0
 platform: ruby
 authors:
 - Andreas Haller
 bindir: bin
 cert_chain: []
-date: 2025-03-26 00:00:00.000000000 Z
+date: 2025-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hana
@@ -102,6 +102,7 @@ files:
 - lib/openapi_first/errors.rb
 - lib/openapi_first/failure.rb
 - lib/openapi_first/file_loader.rb
+- lib/openapi_first/header.rb
 - lib/openapi_first/json.rb
 - lib/openapi_first/middlewares/request_validation.rb
 - lib/openapi_first/middlewares/response_validation.rb
@@ -118,6 +119,7 @@ files:
 - lib/openapi_first/router/find_content.rb
 - lib/openapi_first/router/find_response.rb
 - lib/openapi_first/router/path_template.rb
+- lib/openapi_first/schema/hash.rb
 - lib/openapi_first/schema/validation_error.rb
 - lib/openapi_first/schema/validation_result.rb
 - lib/openapi_first/test.rb