openapi_contracts 0.6.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc0a8f6f92b0615788c15cd3d715fe4308e1058616c6f892140addbcae3b9232
-  data.tar.gz: f7328963227bc196797674e1bd5f04af471a05507d0ec848a8386da5a568c1aa
+  metadata.gz: e6c02afb8cd5c3ad005ff169eb4c1294b8de98dd97c4cd643609a8f3a5cc66d5
+  data.tar.gz: e8808416c903da9662789d67da35fa6b2f44e9ba7659b7baa675ef5cdabbcd8a
 SHA512:
-  metadata.gz: 550501aa45c7e5b66dfa666ecc3354b41a5f8c49d067490c91a964b0bf338ca55b5e785ae578c0e82da15f5d5fdbe2bcd94c99e716fee81d7506ccd7cc05aa24
-  data.tar.gz: fa614dbb218e74bf497ac25d46d284bf32e6c9de9bda65a819f12f26a8172e405c9cd8ad1958fd760b69501e8e98214bdfb63c97e404bdfcb2590c47f1c21a8e
+  metadata.gz: 199fa68a93326277251d413ff5e6c3d2b4718b3345a74cb79f227252a4e741f4cb179f05eaa304b2807b29e64f5510a0c9f5bec817c9373337c68a7f8a1ba8d1
+  data.tar.gz: 81c16071342cf8203380e85ced5bf52974231371d269c72ea4d182b472148b4e801c12cc3ca699237643559c1a52dd935f9b984f73c974e51002061da8b3dfa3

data/README.md

@@ -56,6 +56,15 @@ Example:
 it { is_expected.to match_openapi_doc($api_doc, path: '/messages/{id}').with_http_status(:ok) }
 ```
 
+### Without RSpec
+
+You can also use the Validator directly:
+```ruby
+# Let's raise an error if the response does not match
+result = OpenapiContracts.match($doc, response, options = {})
+raise result.errors.merge("/n") unless result.valid?
+```
+
 ### How it works
 
 It uses the `request.path`, `request.method`, `status` and `headers` on the test subject (which must be the response) to find the response schema in the OpenAPI document. Then it does the following checks:

data/lib/openapi_contracts/doc/file_parser.rb

@@ -0,0 +1,85 @@
+module OpenapiContracts
+  class Doc::FileParser
+    Result = Struct.new(:data, :path) do
+      def to_mergable_hash
+        d = data
+        path.ascend do |p|
+          d = {p.basename.to_s => d}
+        end
+        d
+      end
+    end
+
+    def self.parse(rootfile, pathname)
+      new(rootfile, pathname).call
+    end
+
+    def initialize(rootfile, pathname)
+      @root = rootfile.parent
+      @rootfile = rootfile
+      @pathname = pathname.relative? ? @root.join(pathname) : pathname
+    end
+
+    def call
+      schema = YAML.safe_load(File.read(@pathname))
+      schema = transform_hash(schema)
+      Result.new(schema, @pathname.relative_path_from(@root).sub_ext(''))
+    end
+
+    private
+
+    def transform_hash(data)
+      data.each_with_object({}) do |(key, val), m|
+        if val.is_a?(Array)
+          m[key] = transform_array(val)
+        elsif val.is_a?(Hash)
+          m[key] = transform_hash(val)
+        elsif key == '$ref'
+          m.merge! transform_pointer(key, val)
+        else
+          m[key] = val
+        end
+      end
+    end
+
+    def transform_array(data)
+      data.each_with_object([]) do |item, m|
+        case item
+        when Hash
+          m.push transform_hash(item)
+        when Array
+          m.push transform_array(item)
+        else
+          m.push item
+        end
+      end
+    end
+
+    def transform_pointer(key, target)
+      if %r{^#/(?<pointer>.*)} =~ target
+        # A JSON Pointer
+        {key => generate_absolute_pointer(pointer)}
+      elsif %r{^(?<relpath>[^#]+)(?:#/(?<pointer>.*))?} =~ target
+        if relpath.start_with?('paths') # path description file pointer
+          # Inline the file contents
+          self.class.parse(@rootfile, Pathname(relpath)).data
+        else # A file pointer with potential JSON sub-pointer
+          tgt = @pathname.parent.relative_path_from(@root).join(relpath).sub_ext('')
+          tgt = tgt.join(pointer) if pointer
+          {key => "#/#{tgt}"}
+        end
+      else
+        {key => target}
+      end
+    end
+
+    # A JSON pointer to the currently parsed file as seen from the root openapi file
+    def generate_absolute_pointer(json_pointer)
+      if @rootfile == @pathname
+        "#/#{json_pointer}"
+      else
+        "#/#{@pathname.relative_path_from(@root).sub_ext('').join(json_pointer)}"
+      end
+    end
+  end
+end

data/lib/openapi_contracts/doc/method.rb

@@ -0,0 +1,18 @@
+module OpenapiContracts
+  class Doc::Method
+    def initialize(schema)
+      @schema = schema
+      @responses = schema['responses'].to_h do |status, _|
+        [status, Doc::Response.new(schema.navigate('responses', status))]
+      end
+    end
+
+    def responses
+      @responses.each_value
+    end
+
+    def with_status(status)
+      @responses[status]
+    end
+  end
+end

data/lib/openapi_contracts/doc/parser.rb

@@ -1,38 +1,30 @@
 module OpenapiContracts
   class Doc::Parser
     def self.call(dir, filename)
-      new(dir).parse(filename)
+      new(dir.join(filename)).parse
     end
 
-    def initialize(dir)
-      @dir = dir
+    def initialize(rootfile)
+      @rootfile = rootfile
     end
 
-    def parse(path)
-      abs_path = @dir.join(path)
-      data = parse_file(abs_path, translate: false)
+    def parse
+      file = Doc::FileParser.parse(@rootfile, @rootfile)
+      data = file.data
       data.deep_merge! merge_components
-      data = join_partials(abs_path.dirname, data)
       nullable_to_type!(data)
+      # debugger
     end
 
     private
 
-    def parse_file(path, translate: true)
-      schema = YAML.safe_load(File.read(path))
-      translate ? translate_paths!(schema, Pathname(path).parent) : schema
-    end
-
-    def join_partials(cwd, data)
-      data.each_with_object({}) do |(key, val), m|
-        if val.is_a?(Hash)
-          m[key] = join_partials(cwd, val)
-        elsif key == '$ref' && val !~ /^#/
-          m.merge! parse_file(cwd.join(val))
-        else
-          m[key] = val
-        end
+    def merge_components
+      data = {}
+      Dir[File.expand_path('components/**/*.yaml', @rootfile.parent)].each do |file|
+        result = Doc::FileParser.parse(@rootfile, Pathname(file))
+        data.deep_merge!(result.to_mergable_hash)
       end
+      data
     end
 
     def nullable_to_type!(object)
@@ -48,43 +40,5 @@ module OpenapiContracts
         object.each { |o| nullable_to_type! o }
       end
     end
-
-    def merge_components
-      data = {}
-      Dir[File.expand_path('components/**/*.yaml', @dir)].each do |file|
-        pointer = json_pointer(Pathname(file)).split('/')
-        i = 0
-        pointer.reduce(data) do |h, p|
-          i += 1
-          if i == pointer.size
-            h[p] = parse_file(file)
-          else
-            h[p] ||= {}
-          end
-          h[p]
-        end
-      end
-      data
-    end
-
-    def translate_paths!(data, cwd)
-      case data
-      when Array
-        data.each { |v| translate_paths!(v, cwd) }
-      when Hash
-        data.each_pair do |k, v|
-          if k == '$ref' && v !~ %r{^#/}
-            v.replace json_pointer(cwd.join(v), '#/')
-          else
-            translate_paths!(v, cwd)
-          end
-        end
-      end
-    end
-
-    def json_pointer(pathname, prefix = '')
-      relative = pathname.relative_path_from(@dir)
-      "#{prefix}#{relative.to_s.delete_suffix(pathname.extname)}"
-    end
   end
 end

data/lib/openapi_contracts/doc/path.rb

@@ -0,0 +1,26 @@
+module OpenapiContracts
+  class Doc::Path
+    def initialize(schema)
+      @schema = schema
+
+      @methods = (known_http_methods & @schema.keys).to_h do |method|
+        [method, Doc::Method.new(@schema.navigate(method))]
+      end
+    end
+
+    def methods
+      @methods.each_value
+    end
+
+    def with_method(method)
+      @methods[method]
+    end
+
+    private
+
+    def known_http_methods
+      # https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods
+      %w(get head post put delete connect options trace patch).freeze
+    end
+  end
+end

data/lib/openapi_contracts/doc/schema.rb

@@ -1,38 +1,45 @@
 module OpenapiContracts
+  # Represents a part or the whole schema
+  # Generally even parts of the schema contain the whole schema, but store the pointer to
+  # their position in the overall schema. This allows even small sub-schemas to resolve
+  # links to any other part of the schema
   class Doc::Schema
-    attr_reader :path, :schema
+    attr_reader :pointer, :raw
 
-    def initialize(schema, path = nil)
-      @schema = schema
-      @path = path.freeze
+    def initialize(raw, pointer = nil)
+      @raw = raw
+      @pointer = pointer.freeze
     end
 
+    # Resolves Schema ref pointers links like "$ref: #/some/path" and returns new sub-schema
+    # at the target if the current schema is only a ref link.
     def follow_refs
-      if (ref = dig('$ref'))
-        at_path(ref.split('/')[1..])
+      if (ref = as_h['$ref'])
+        at_pointer(ref.split('/')[1..])
       else
         self
       end
     end
 
+    # Generates a fragment pointer for the current schema path
     def fragment
-      path.map { |p| p.gsub('/', '~1') }.join('/').then { |s| "#/#{s}" }
+      pointer.map { |p| p.gsub('/', '~1') }.join('/').then { |s| "#/#{s}" }
     end
 
-    delegate :dig, :fetch, :key?, :[], to: :to_h
+    delegate :dig, :fetch, :keys, :key?, :[], :to_h, to: :as_h
 
-    def at_path(path)
-      self.class.new(schema, path)
+    def at_pointer(pointer)
+      self.class.new(raw, pointer)
     end
 
-    def to_h
-      return @schema if path.nil? || path.empty?
+    def as_h
+      return @raw if pointer.nil? || pointer.empty?
 
-      @schema.dig(*path)
+      @raw.dig(*pointer)
     end
 
-    def navigate(*sub_path)
-      self.class.new(schema, (path + Array.wrap(sub_path)))
+    def navigate(*spointer)
+      self.class.new(@raw, (pointer + Array.wrap(spointer)))
     end
   end
 end

data/lib/openapi_contracts/doc.rb

@@ -1,25 +1,48 @@
 module OpenapiContracts
   class Doc
-    autoload :Header,   'openapi_contracts/doc/header'
-    autoload :Parser,   'openapi_contracts/doc/parser'
-    autoload :Response, 'openapi_contracts/doc/response'
-    autoload :Schema,   'openapi_contracts/doc/schema'
+    autoload :Header,     'openapi_contracts/doc/header'
+    autoload :FileParser, 'openapi_contracts/doc/file_parser'
+    autoload :Method,     'openapi_contracts/doc/method'
+    autoload :Parser,     'openapi_contracts/doc/parser'
+    autoload :Path,       'openapi_contracts/doc/path'
+    autoload :Response,   'openapi_contracts/doc/response'
+    autoload :Schema,     'openapi_contracts/doc/schema'
 
     def self.parse(dir, filename = 'openapi.yaml')
       new Parser.call(dir, filename)
     end
 
+    attr_reader :schema
+
     def initialize(schema)
       @schema = Schema.new(schema)
+      @paths = @schema['paths'].to_h do |path, _|
+        [path, Path.new(@schema.at_pointer(['paths', path]))]
+      end
     end
 
-    delegate :dig, :fetch, :[], :at_path, to: :@schema
+    # Returns an Enumerator over all paths
+    def paths
+      @paths.each_value
+    end
 
     def response_for(path, method, status)
-      path = ['paths', path, method, 'responses', status]
-      return unless dig(*path).present?
+      with_path(path)&.with_method(method)&.with_status(status)
+    end
+
+    # Returns an Enumerator over all Responses
+    def responses(&block)
+      return enum_for(:responses) unless block_given?
+
+      paths.each do |path|
+        path.methods.each do |method|
+          method.responses.each(&block)
+        end
+      end
+    end
 
-      Response.new(@schema.at_path(path))
+    def with_path(path)
+      @paths[path]
     end
   end
 end

data/lib/openapi_contracts/helper.rb

@@ -0,0 +1,7 @@
+module OpenapiContracts
+  module Helper
+    def http_status_desc(status)
+      "http status #{Rack::Utils::HTTP_STATUS_CODES[status]} (#{status})"
+    end
+  end
+end

data/lib/openapi_contracts/match.rb

@@ -0,0 +1,34 @@
+module OpenapiContracts
+  class Match
+    attr_reader :errors
+
+    def initialize(doc, response, options = {})
+      @doc = doc
+      @response = response
+      @options = options
+    end
+
+    def valid?
+      return @errors.empty? if instance_variable_defined?(:@errors)
+
+      @errors = matchers.call
+      @errors.empty?
+    end
+
+    private
+
+    def lookup_api_spec
+      @doc.response_for(
+        @options.fetch(:path, @response.request.path),
+        @response.request.request_method.downcase,
+        @response.status.to_s
+      )
+    end
+
+    def matchers
+      env = Env.new(lookup_api_spec, @response, @options[:status])
+      Validators::ALL.reverse
+                     .reduce(->(err) { err }) { |s, m| m.new(s, env) }
+    end
+  end
+end

data/lib/openapi_contracts/rspec.rb

@@ -0,0 +1,34 @@
+RSpec::Matchers.define :match_openapi_doc do |doc, options = {}| # rubocop:disable Metrics/BlockLength
+  include OpenapiContracts::Helper
+
+  match do |response|
+    match = OpenapiContracts::Match.new(
+      doc,
+      response,
+      options.merge({status: @status}.compact)
+    )
+    return true if match.valid?
+
+    @errors = match.errors
+    false
+  end
+
+  description do
+    desc = 'to match the openapi schema'
+    desc << " with #{http_status_desc(@status)}" if @status
+    desc
+  end
+
+  failure_message do |_reponse|
+    @errors.map { |e| "* #{e}" }.join("\n")
+  end
+
+  def with_http_status(status)
+    if status.is_a? Symbol
+      @status = Rack::Utils::SYMBOL_TO_STATUS_CODE[status]
+    else
+      @status = status
+    end
+    self
+  end
+end

data/lib/openapi_contracts/validators/base.rb

@@ -0,0 +1,33 @@
+module OpenapiContracts::Validators
+  class Base
+    include OpenapiContracts::Helper
+
+    class_attribute :final, instance_writer: false
+    self.final = false
+
+    def initialize(stack, env)
+      @stack = stack # next matcher
+      @env = env
+      @errors = []
+    end
+
+    def call(errors = [])
+      validate
+      errors.push(*@errors)
+      # Do not call the next matcher when there is errors on a final matcher
+      return errors if @errors.any? && final?
+
+      @stack.call(errors)
+    end
+
+    private
+
+    delegate :expected_status, :response, :spec, to: :@env
+
+    # :nocov:
+    def validate
+      raise NotImplementedError
+    end
+    # :nocov:
+  end
+end

data/lib/openapi_contracts/validators/body.rb

@@ -0,0 +1,38 @@
+module OpenapiContracts::Validators
+  class Body < Base
+    private
+
+    def validate
+      if spec.no_content?
+        @errors << 'Expected empty response body' if response.body.present?
+      elsif !spec.supports_content_type?(response_content_type)
+        @errors << "Undocumented response with content-type #{response_content_type.inspect}"
+      else
+        validate_schema
+      end
+    end
+
+    def validate_schema
+      schema = spec.schema_for(response_content_type)
+      # Trick JSONSchemer into validating only against the response schema
+      schemer = JSONSchemer.schema(schema.raw.merge('$ref' => schema.fragment))
+      schemer.validate(JSON(response.body)).each do |err|
+        @errors << error_to_message(err)
+      end
+    end
+
+    def error_to_message(error)
+      if error.key?('details')
+        error['details'].to_a.map do |(key, val)|
+          "#{key.humanize}: #{val} at #{error['data_pointer']}"
+        end.to_sentence
+      else
+        "#{error['data'].inspect} at #{error['data_pointer']} does not match the schema"
+      end
+    end
+
+    def response_content_type
+      response.headers['Content-Type'].split(';').first
+    end
+  end
+end

data/lib/openapi_contracts/validators/documented.rb

@@ -0,0 +1,18 @@
+module OpenapiContracts::Validators
+  class Documented < Base
+    self.final = true
+
+    private
+
+    def validate
+      return if spec
+
+      status_desc = http_status_desc(response.status)
+      @errors << "Undocumented request/response for #{response_desc.inspect} with #{status_desc}"
+    end
+
+    def response_desc
+      "#{response.request.request_method} #{response.request.path}"
+    end
+  end
+end

data/lib/openapi_contracts/validators/headers.rb

@@ -0,0 +1,16 @@
+module OpenapiContracts::Validators
+  class Headers < Base
+    private
+
+    def validate
+      spec.headers.each do |header|
+        value = response.headers[header.name]
+        if value.blank?
+          @errors << "Missing header #{header.name}" if header.required?
+        elsif !JSONSchemer.schema(header.schema).valid?(value)
+          @errors << "Header #{header.name} does not match"
+        end
+      end
+    end
+  end
+end

data/lib/openapi_contracts/validators/http_status.rb

@@ -0,0 +1,17 @@
+module OpenapiContracts::Validators
+  class HttpStatus < Base
+    self.final = true
+
+    private
+
+    def validate
+      return if expected_status.blank? || expected_status == response.status
+
+      @errors << "Response has #{http_status_desc}"
+    end
+
+    def http_status_desc
+      "http status #{Rack::Utils::HTTP_STATUS_CODES[response.status]} (#{response.status})"
+    end
+  end
+end

data/lib/openapi_contracts/validators.rb

@@ -0,0 +1,17 @@
+module OpenapiContracts
+  module Validators
+    autoload :Base,       'openapi_contracts/validators/base'
+    autoload :Body,       'openapi_contracts/validators/body'
+    autoload :Documented, 'openapi_contracts/validators/documented'
+    autoload :Headers,    'openapi_contracts/validators/headers'
+    autoload :HttpStatus, 'openapi_contracts/validators/http_status'
+
+    # Defines order of matching
+    ALL = [
+      Documented,
+      HttpStatus,
+      Body,
+      Headers
+    ].freeze
+  end
+end

data/lib/openapi_contracts.rb

@@ -1,5 +1,6 @@
 require 'active_support'
 require 'active_support/core_ext/array'
+require 'active_support/core_ext/class'
 require 'active_support/core_ext/module'
 require 'active_support/core_ext/string'
 
@@ -7,12 +8,18 @@ require 'json_schemer'
 require 'yaml'
 
 module OpenapiContracts
-  autoload :Doc,      'openapi_contracts/doc'
-  autoload :Matchers, 'openapi_contracts/matchers'
-end
+  autoload :Doc,        'openapi_contracts/doc'
+  autoload :Helper,     'openapi_contracts/helper'
+  autoload :Match,      'openapi_contracts/match'
+  autoload :Validators, 'openapi_contracts/validators'
+
+  Env = Struct.new(:spec, :response, :expected_status)
 
-if defined?(RSpec)
-  RSpec.configure do |config|
-    config.include OpenapiContracts::Matchers
+  module_function
+
+  def match(doc, response, options = {})
+    Match.new(doc, response, options)
   end
 end
+
+require 'openapi_contracts/rspec' if defined?(RSpec)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openapi_contracts
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.1
 platform: ruby
 authors:
 - mkon
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-11 00:00:00.000000000 Z
+date: 2023-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -44,6 +44,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.2.20
+- !ruby/object:Gem::Dependency
+  name: json_spec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.5
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
@@ -78,28 +92,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.44.1
+        version: 1.52.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.44.1
+        version: 1.52.0
 - !ruby/object:Gem::Dependency
   name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.18.1
+        version: 2.22.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.18.1
+        version: 2.22.0
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -124,12 +138,22 @@ files:
 - README.md
 - lib/openapi_contracts.rb
 - lib/openapi_contracts/doc.rb
+- lib/openapi_contracts/doc/file_parser.rb
 - lib/openapi_contracts/doc/header.rb
+- lib/openapi_contracts/doc/method.rb
 - lib/openapi_contracts/doc/parser.rb
+- lib/openapi_contracts/doc/path.rb
 - lib/openapi_contracts/doc/response.rb
 - lib/openapi_contracts/doc/schema.rb
-- lib/openapi_contracts/matchers.rb
-- lib/openapi_contracts/matchers/match_openapi_doc.rb
+- lib/openapi_contracts/helper.rb
+- lib/openapi_contracts/match.rb
+- lib/openapi_contracts/rspec.rb
+- lib/openapi_contracts/validators.rb
+- lib/openapi_contracts/validators/base.rb
+- lib/openapi_contracts/validators/body.rb
+- lib/openapi_contracts/validators/documented.rb
+- lib/openapi_contracts/validators/headers.rb
+- lib/openapi_contracts/validators/http_status.rb
 homepage: https://github.com/mkon/openapi_contracts
 licenses:
 - MIT
@@ -153,7 +177,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.4.6
 signing_key:
 specification_version: 4
 summary: Openapi schemas as API contracts

data/lib/openapi_contracts/matchers/match_openapi_doc.rb

@@ -1,116 +0,0 @@
-module OpenapiContracts
-  module Matchers
-    class MatchOpenapiDoc
-      def initialize(doc, options)
-        @doc = doc
-        @options = options
-        @errors = []
-      end
-
-      def with_http_status(status)
-        if status.is_a? Symbol
-          @status = Rack::Utils::SYMBOL_TO_STATUS_CODE[status]
-        else
-          @status = status
-        end
-        self
-      end
-
-      def matches?(response)
-        @response = response
-        response_documented? && http_status_matches? && [headers_match?, body_matches?].all?
-        @errors.empty?
-      end
-
-      def description
-        desc = 'to match the openapi schema'
-        desc << " with #{http_status_desc(@status)}" if @status
-        desc
-      end
-
-      def failure_message
-        @errors.map { |e| "* #{e}" }.join("\n")
-      end
-
-      def failure_message_when_negated
-        'request matched the schema'
-      end
-
-      private
-
-      def response_desc
-        "#{@response.request.request_method} #{@response.request.path}"
-      end
-
-      def response_spec
-        @response_spec ||= @doc.response_for(
-          @options.fetch(:path, @response.request.path),
-          @response.request.request_method.downcase,
-          @response.status.to_s
-        )
-      end
-
-      def response_content_type
-        @response.headers['Content-Type'].split(';').first
-      end
-
-      def headers_match?
-        response_spec.headers.each do |header|
-          value = @response.headers[header.name]
-          if value.blank?
-            @errors << "Missing header #{header.name}" if header.required?
-          elsif !JSONSchemer.schema(header.schema).valid?(value)
-            @errors << "Header #{header.name} does not match"
-          end
-        end
-        @errors.empty?
-      end
-
-      def http_status_desc(status = nil)
-        status ||= @response.status
-        "http status #{Rack::Utils::HTTP_STATUS_CODES[status]} (#{status})"
-      end
-
-      def http_status_matches?
-        if @status.present? && @status != @response.status
-          @errors << "Response has #{http_status_desc}"
-          false
-        else
-          true
-        end
-      end
-
-      def body_matches?
-        if response_spec.no_content?
-          @errors << 'Expected empty response body' if @response.body.present?
-        elsif !response_spec.supports_content_type?(response_content_type)
-          @errors << "Undocumented response with content-type #{response_content_type.inspect}"
-        else
-          @schema = response_spec.schema_for(response_content_type)
-          schemer = JSONSchemer.schema(@schema.schema.merge('$ref' => @schema.fragment))
-          schemer.validate(JSON(@response.body)).each do |err|
-            @errors << error_to_message(err)
-          end
-        end
-        @errors.empty?
-      end
-
-      def error_to_message(error)
-        if error.key?('details')
-          error['details'].to_a.map do |(key, val)|
-            "#{key.humanize}: #{val} at #{error['data_pointer']}"
-          end.to_sentence
-        else
-          "#{error['data'].inspect} at #{error['data_pointer']} does not match the schema"
-        end
-      end
-
-      def response_documented?
-        return true if response_spec
-
-        @errors << "Undocumented request/response for #{response_desc.inspect} with #{http_status_desc}"
-        false
-      end
-    end
-  end
-end

data/lib/openapi_contracts/matchers.rb

@@ -1,9 +0,0 @@
-module OpenapiContracts
-  module Matchers
-    autoload :MatchOpenapiDoc, 'openapi_contracts/matchers/match_openapi_doc'
-
-    def match_openapi_doc(doc, options = {})
-      MatchOpenapiDoc.new(doc, options)
-    end
-  end
-end